diff --git a/crates/jacquard-api/src/actor_rpg/master.rs b/crates/jacquard-api/src/actor_rpg/master.rs
index 5d6a7ca5..cfa96dfc 100644
--- a/crates/jacquard-api/src/actor_rpg/master.rs
+++ b/crates/jacquard-api/src/actor_rpg/master.rs
@@ -233,51 +233,51 @@ pub mod master_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Player;
         type CreatedAt;
         type System;
-        type Player;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Player = Unset;
         type CreatedAt = Unset;
         type System = Unset;
-        type Player = Unset;
+    }
+    ///State transition - sets the `player` field to Set
+    pub struct SetPlayer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlayer<St> {}
+    impl<St: State> State for SetPlayer<St> {
+        type Player = Set<members::player>;
+        type CreatedAt = St::CreatedAt;
+        type System = St::System;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Player = St::Player;
         type CreatedAt = Set<members::created_at>;
         type System = St::System;
-        type Player = St::Player;
     }
     ///State transition - sets the `system` field to Set
     pub struct SetSystem<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSystem<St> {}
     impl<St: State> State for SetSystem<St> {
-        type CreatedAt = St::CreatedAt;
-        type System = Set<members::system>;
         type Player = St::Player;
-    }
-    ///State transition - sets the `player` field to Set
-    pub struct SetPlayer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlayer<St> {}
-    impl<St: State> State for SetPlayer<St> {
         type CreatedAt = St::CreatedAt;
-        type System = St::System;
-        type Player = Set<members::player>;
+        type System = Set<members::system>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `player` field
+        pub struct player(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `system` field
         pub struct system(());
-        ///Marker type for the `player` field
-        pub struct player(());
     }
 }
 
@@ -446,9 +446,9 @@ impl<S: BosStr, St: master_state::State> MasterBuilder<S, St> {
 impl<S: BosStr, St> MasterBuilder<S, St>
 where
     St: master_state::State,
+    St::Player: master_state::IsSet,
     St::CreatedAt: master_state::IsSet,
     St::System: master_state::IsSet,
-    St::Player: master_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Master<S> {
diff --git a/crates/jacquard-api/src/actor_rpg/sprite.rs b/crates/jacquard-api/src/actor_rpg/sprite.rs
index e7d759b4..9fe5693f 100644
--- a/crates/jacquard-api/src/actor_rpg/sprite.rs
+++ b/crates/jacquard-api/src/actor_rpg/sprite.rs
@@ -445,51 +445,51 @@ pub mod sprite_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Engine;
         type CreatedAt;
         type SpriteSheet;
-        type Engine;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Engine = Unset;
         type CreatedAt = Unset;
         type SpriteSheet = Unset;
-        type Engine = Unset;
+    }
+    ///State transition - sets the `engine` field to Set
+    pub struct SetEngine<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEngine<St> {}
+    impl<St: State> State for SetEngine<St> {
+        type Engine = Set<members::engine>;
+        type CreatedAt = St::CreatedAt;
+        type SpriteSheet = St::SpriteSheet;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Engine = St::Engine;
         type CreatedAt = Set<members::created_at>;
         type SpriteSheet = St::SpriteSheet;
-        type Engine = St::Engine;
     }
     ///State transition - sets the `sprite_sheet` field to Set
     pub struct SetSpriteSheet<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSpriteSheet<St> {}
     impl<St: State> State for SetSpriteSheet<St> {
-        type CreatedAt = St::CreatedAt;
-        type SpriteSheet = Set<members::sprite_sheet>;
         type Engine = St::Engine;
-    }
-    ///State transition - sets the `engine` field to Set
-    pub struct SetEngine<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEngine<St> {}
-    impl<St: State> State for SetEngine<St> {
         type CreatedAt = St::CreatedAt;
-        type SpriteSheet = St::SpriteSheet;
-        type Engine = Set<members::engine>;
+        type SpriteSheet = Set<members::sprite_sheet>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `engine` field
+        pub struct engine(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `sprite_sheet` field
         pub struct sprite_sheet(());
-        ///Marker type for the `engine` field
-        pub struct engine(());
     }
 }
 
@@ -736,9 +736,9 @@ impl<S: BosStr, St: sprite_state::State> SpriteBuilder<S, St> {
 impl<S: BosStr, St> SpriteBuilder<S, St>
 where
     St: sprite_state::State,
+    St::Engine: sprite_state::IsSet,
     St::CreatedAt: sprite_state::IsSet,
     St::SpriteSheet: sprite_state::IsSet,
-    St::Engine: sprite_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Sprite<S> {
diff --git a/crates/jacquard-api/src/actor_rpg/stats.rs b/crates/jacquard-api/src/actor_rpg/stats.rs
index ecf01c8a..65f8801d 100644
--- a/crates/jacquard-api/src/actor_rpg/stats.rs
+++ b/crates/jacquard-api/src/actor_rpg/stats.rs
@@ -7658,37 +7658,37 @@ pub mod spellslot_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Level;
         type Total;
+        type Level;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Level = Unset;
         type Total = Unset;
-    }
-    ///State transition - sets the `level` field to Set
-    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLevel<St> {}
-    impl<St: State> State for SetLevel<St> {
-        type Level = Set<members::level>;
-        type Total = St::Total;
+        type Level = Unset;
     }
     ///State transition - sets the `total` field to Set
     pub struct SetTotal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotal<St> {}
     impl<St: State> State for SetTotal<St> {
-        type Level = St::Level;
         type Total = Set<members::total>;
+        type Level = St::Level;
+    }
+    ///State transition - sets the `level` field to Set
+    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLevel<St> {}
+    impl<St: State> State for SetLevel<St> {
+        type Total = St::Total;
+        type Level = Set<members::level>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `level` field
-        pub struct level(());
         ///Marker type for the `total` field
         pub struct total(());
+        ///Marker type for the `level` field
+        pub struct level(());
     }
 }
 
@@ -7771,8 +7771,8 @@ impl<S: BosStr, St: spellslot_state::State> SpellslotBuilder<S, St> {
 impl<S: BosStr, St> SpellslotBuilder<S, St>
 where
     St: spellslot_state::State,
-    St::Level: spellslot_state::IsSet,
     St::Total: spellslot_state::IsSet,
+    St::Level: spellslot_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Spellslot<S> {
diff --git a/crates/jacquard-api/src/ai_syui/log/chat.rs b/crates/jacquard-api/src/ai_syui/log/chat.rs
index 14410a80..f6292198 100644
--- a/crates/jacquard-api/src/ai_syui/log/chat.rs
+++ b/crates/jacquard-api/src/ai_syui/log/chat.rs
@@ -399,49 +399,49 @@ pub mod chat_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Site;
         type Title;
+        type Site;
         type PublishedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Site = Unset;
         type Title = Unset;
+        type Site = Unset;
         type PublishedAt = Unset;
     }
-    ///State transition - sets the `site` field to Set
-    pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSite<St> {}
-    impl<St: State> State for SetSite<St> {
-        type Site = Set<members::site>;
-        type Title = St::Title;
-        type PublishedAt = St::PublishedAt;
-    }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Site = St::Site;
         type Title = Set<members::title>;
+        type Site = St::Site;
+        type PublishedAt = St::PublishedAt;
+    }
+    ///State transition - sets the `site` field to Set
+    pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSite<St> {}
+    impl<St: State> State for SetSite<St> {
+        type Title = St::Title;
+        type Site = Set<members::site>;
         type PublishedAt = St::PublishedAt;
     }
     ///State transition - sets the `published_at` field to Set
     pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublishedAt<St> {}
     impl<St: State> State for SetPublishedAt<St> {
-        type Site = St::Site;
         type Title = St::Title;
+        type Site = St::Site;
         type PublishedAt = Set<members::published_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `site` field
-        pub struct site(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `site` field
+        pub struct site(());
         ///Marker type for the `published_at` field
         pub struct published_at(());
     }
@@ -723,8 +723,8 @@ impl<S: BosStr, St: chat_state::State> ChatBuilder<S, St> {
 impl<S: BosStr, St> ChatBuilder<S, St>
 where
     St: chat_state::State,
-    St::Site: chat_state::IsSet,
     St::Title: chat_state::IsSet,
+    St::Site: chat_state::IsSet,
     St::PublishedAt: chat_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_beaconbits/beacon.rs b/crates/jacquard-api/src/app_beaconbits/beacon.rs
index 14a7648f..db74a027 100644
--- a/crates/jacquard-api/src/app_beaconbits/beacon.rs
+++ b/crates/jacquard-api/src/app_beaconbits/beacon.rs
@@ -367,65 +367,65 @@ pub mod beacon_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Visibility;
         type CreatedAt;
         type VenueUri;
-        type Visibility;
         type VenueName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Visibility = Unset;
         type CreatedAt = Unset;
         type VenueUri = Unset;
-        type Visibility = Unset;
         type VenueName = Unset;
     }
+    ///State transition - sets the `visibility` field to Set
+    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVisibility<St> {}
+    impl<St: State> State for SetVisibility<St> {
+        type Visibility = Set<members::visibility>;
+        type CreatedAt = St::CreatedAt;
+        type VenueUri = St::VenueUri;
+        type VenueName = St::VenueName;
+    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Visibility = St::Visibility;
         type CreatedAt = Set<members::created_at>;
         type VenueUri = St::VenueUri;
-        type Visibility = St::Visibility;
         type VenueName = St::VenueName;
     }
     ///State transition - sets the `venue_uri` field to Set
     pub struct SetVenueUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVenueUri<St> {}
     impl<St: State> State for SetVenueUri<St> {
-        type CreatedAt = St::CreatedAt;
-        type VenueUri = Set<members::venue_uri>;
         type Visibility = St::Visibility;
-        type VenueName = St::VenueName;
-    }
-    ///State transition - sets the `visibility` field to Set
-    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVisibility<St> {}
-    impl<St: State> State for SetVisibility<St> {
         type CreatedAt = St::CreatedAt;
-        type VenueUri = St::VenueUri;
-        type Visibility = Set<members::visibility>;
+        type VenueUri = Set<members::venue_uri>;
         type VenueName = St::VenueName;
     }
     ///State transition - sets the `venue_name` field to Set
     pub struct SetVenueName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVenueName<St> {}
     impl<St: State> State for SetVenueName<St> {
+        type Visibility = St::Visibility;
         type CreatedAt = St::CreatedAt;
         type VenueUri = St::VenueUri;
-        type Visibility = St::Visibility;
         type VenueName = Set<members::venue_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `visibility` field
+        pub struct visibility(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `venue_uri` field
         pub struct venue_uri(());
-        ///Marker type for the `visibility` field
-        pub struct visibility(());
         ///Marker type for the `venue_name` field
         pub struct venue_name(());
     }
@@ -740,9 +740,9 @@ where
 impl<S: BosStr, St> BeaconBuilder<S, St>
 where
     St: beacon_state::State,
+    St::Visibility: beacon_state::IsSet,
     St::CreatedAt: beacon_state::IsSet,
     St::VenueUri: beacon_state::IsSet,
-    St::Visibility: beacon_state::IsSet,
     St::VenueName: beacon_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_beaconbits/bookmark/folder.rs b/crates/jacquard-api/src/app_beaconbits/bookmark/folder.rs
index ad2ed22d..6ad4c56e 100644
--- a/crates/jacquard-api/src/app_beaconbits/bookmark/folder.rs
+++ b/crates/jacquard-api/src/app_beaconbits/bookmark/folder.rs
@@ -270,37 +270,37 @@ pub mod folder_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -429,8 +429,8 @@ impl<S: BosStr, St: folder_state::State> FolderBuilder<S, St> {
 impl<S: BosStr, St> FolderBuilder<S, St>
 where
     St: folder_state::State,
-    St::Name: folder_state::IsSet,
     St::CreatedAt: folder_state::IsSet,
+    St::Name: folder_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Folder<S> {
diff --git a/crates/jacquard-api/src/app_beaconbits/bookmark/item.rs b/crates/jacquard-api/src/app_beaconbits/bookmark/item.rs
index 80a339ec..cf841ed4 100644
--- a/crates/jacquard-api/src/app_beaconbits/bookmark/item.rs
+++ b/crates/jacquard-api/src/app_beaconbits/bookmark/item.rs
@@ -198,49 +198,49 @@ pub mod item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type VenueUri;
         type CreatedAt;
+        type VenueUri;
         type VenueName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type VenueUri = Unset;
         type CreatedAt = Unset;
+        type VenueUri = Unset;
         type VenueName = Unset;
     }
-    ///State transition - sets the `venue_uri` field to Set
-    pub struct SetVenueUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVenueUri<St> {}
-    impl<St: State> State for SetVenueUri<St> {
-        type VenueUri = Set<members::venue_uri>;
-        type CreatedAt = St::CreatedAt;
-        type VenueName = St::VenueName;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type VenueUri = St::VenueUri;
         type CreatedAt = Set<members::created_at>;
+        type VenueUri = St::VenueUri;
+        type VenueName = St::VenueName;
+    }
+    ///State transition - sets the `venue_uri` field to Set
+    pub struct SetVenueUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVenueUri<St> {}
+    impl<St: State> State for SetVenueUri<St> {
+        type CreatedAt = St::CreatedAt;
+        type VenueUri = Set<members::venue_uri>;
         type VenueName = St::VenueName;
     }
     ///State transition - sets the `venue_name` field to Set
     pub struct SetVenueName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVenueName<St> {}
     impl<St: State> State for SetVenueName<St> {
-        type VenueUri = St::VenueUri;
         type CreatedAt = St::CreatedAt;
+        type VenueUri = St::VenueUri;
         type VenueName = Set<members::venue_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `venue_uri` field
-        pub struct venue_uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `venue_uri` field
+        pub struct venue_uri(());
         ///Marker type for the `venue_name` field
         pub struct venue_name(());
     }
@@ -419,8 +419,8 @@ where
 impl<S: BosStr, St> ItemBuilder<S, St>
 where
     St: item_state::State,
-    St::VenueUri: item_state::IsSet,
     St::CreatedAt: item_state::IsSet,
+    St::VenueUri: item_state::IsSet,
     St::VenueName: item_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_beaconbits/venue.rs b/crates/jacquard-api/src/app_beaconbits/venue.rs
index 7c35efa3..601f9f74 100644
--- a/crates/jacquard-api/src/app_beaconbits/venue.rs
+++ b/crates/jacquard-api/src/app_beaconbits/venue.rs
@@ -168,37 +168,37 @@ pub mod venue_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -341,8 +341,8 @@ impl<S: BosStr, St: venue_state::State> VenueBuilder<S, St> {
 impl<S: BosStr, St> VenueBuilder<S, St>
 where
     St: venue_state::State,
-    St::Name: venue_state::IsSet,
     St::CreatedAt: venue_state::IsSet,
+    St::Name: venue_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Venue<S> {
diff --git a/crates/jacquard-api/src/app_bsky/actor.rs b/crates/jacquard-api/src/app_bsky/actor.rs
index f080f18d..0dd63160 100644
--- a/crates/jacquard-api/src/app_bsky/actor.rs
+++ b/crates/jacquard-api/src/app_bsky/actor.rs
@@ -7134,51 +7134,51 @@ pub mod verification_state_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Verifications;
         type VerifiedStatus;
         type TrustedVerifierStatus;
-        type Verifications;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Verifications = Unset;
         type VerifiedStatus = Unset;
         type TrustedVerifierStatus = Unset;
-        type Verifications = Unset;
+    }
+    ///State transition - sets the `verifications` field to Set
+    pub struct SetVerifications<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVerifications<St> {}
+    impl<St: State> State for SetVerifications<St> {
+        type Verifications = Set<members::verifications>;
+        type VerifiedStatus = St::VerifiedStatus;
+        type TrustedVerifierStatus = St::TrustedVerifierStatus;
     }
     ///State transition - sets the `verified_status` field to Set
     pub struct SetVerifiedStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVerifiedStatus<St> {}
     impl<St: State> State for SetVerifiedStatus<St> {
+        type Verifications = St::Verifications;
         type VerifiedStatus = Set<members::verified_status>;
         type TrustedVerifierStatus = St::TrustedVerifierStatus;
-        type Verifications = St::Verifications;
     }
     ///State transition - sets the `trusted_verifier_status` field to Set
     pub struct SetTrustedVerifierStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTrustedVerifierStatus<St> {}
     impl<St: State> State for SetTrustedVerifierStatus<St> {
-        type VerifiedStatus = St::VerifiedStatus;
-        type TrustedVerifierStatus = Set<members::trusted_verifier_status>;
         type Verifications = St::Verifications;
-    }
-    ///State transition - sets the `verifications` field to Set
-    pub struct SetVerifications<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVerifications<St> {}
-    impl<St: State> State for SetVerifications<St> {
         type VerifiedStatus = St::VerifiedStatus;
-        type TrustedVerifierStatus = St::TrustedVerifierStatus;
-        type Verifications = Set<members::verifications>;
+        type TrustedVerifierStatus = Set<members::trusted_verifier_status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `verifications` field
+        pub struct verifications(());
         ///Marker type for the `verified_status` field
         pub struct verified_status(());
         ///Marker type for the `trusted_verifier_status` field
         pub struct trusted_verifier_status(());
-        ///Marker type for the `verifications` field
-        pub struct verifications(());
     }
 }
 
@@ -7274,9 +7274,9 @@ where
 impl<S: BosStr, St> VerificationStateBuilder<S, St>
 where
     St: verification_state_state::State,
+    St::Verifications: verification_state_state::IsSet,
     St::VerifiedStatus: verification_state_state::IsSet,
     St::TrustedVerifierStatus: verification_state_state::IsSet,
-    St::Verifications: verification_state_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> VerificationState<S> {
@@ -7312,66 +7312,66 @@ pub mod verification_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Uri;
-        type Issuer;
         type IsValid;
         type CreatedAt;
+        type Issuer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Uri = Unset;
-        type Issuer = Unset;
         type IsValid = Unset;
         type CreatedAt = Unset;
+        type Issuer = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Uri = Set<members::uri>;
-        type Issuer = St::Issuer;
-        type IsValid = St::IsValid;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `issuer` field to Set
-    pub struct SetIssuer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIssuer<St> {}
-    impl<St: State> State for SetIssuer<St> {
-        type Uri = St::Uri;
-        type Issuer = Set<members::issuer>;
         type IsValid = St::IsValid;
         type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
     }
     ///State transition - sets the `is_valid` field to Set
     pub struct SetIsValid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIsValid<St> {}
     impl<St: State> State for SetIsValid<St> {
         type Uri = St::Uri;
-        type Issuer = St::Issuer;
         type IsValid = Set<members::is_valid>;
         type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Uri = St::Uri;
-        type Issuer = St::Issuer;
         type IsValid = St::IsValid;
         type CreatedAt = Set<members::created_at>;
+        type Issuer = St::Issuer;
+    }
+    ///State transition - sets the `issuer` field to Set
+    pub struct SetIssuer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIssuer<St> {}
+    impl<St: State> State for SetIssuer<St> {
+        type Uri = St::Uri;
+        type IsValid = St::IsValid;
+        type CreatedAt = St::CreatedAt;
+        type Issuer = Set<members::issuer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `issuer` field
-        pub struct issuer(());
         ///Marker type for the `is_valid` field
         pub struct is_valid(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `issuer` field
+        pub struct issuer(());
     }
 }
 
@@ -7480,9 +7480,9 @@ impl<S: BosStr, St> VerificationViewBuilder<S, St>
 where
     St: verification_view_state::State,
     St::Uri: verification_view_state::IsSet,
-    St::Issuer: verification_view_state::IsSet,
     St::IsValid: verification_view_state::IsSet,
     St::CreatedAt: verification_view_state::IsSet,
+    St::Issuer: verification_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> VerificationView<S> {
diff --git a/crates/jacquard-api/src/app_bsky/actor/status.rs b/crates/jacquard-api/src/app_bsky/actor/status.rs
index f4d9fa42..d24fe1ac 100644
--- a/crates/jacquard-api/src/app_bsky/actor/status.rs
+++ b/crates/jacquard-api/src/app_bsky/actor/status.rs
@@ -214,37 +214,37 @@ pub mod status_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type CreatedAt;
+        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type CreatedAt = St::CreatedAt;
+        type Status = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Status = St::Status;
         type CreatedAt = Set<members::created_at>;
+        type Status = St::Status;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type CreatedAt = St::CreatedAt;
+        type Status = Set<members::status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
     }
 }
 
@@ -345,8 +345,8 @@ where
 impl<S: BosStr, St> StatusBuilder<S, St>
 where
     St: status_state::State,
-    St::Status: status_state::IsSet,
     St::CreatedAt: status_state::IsSet,
+    St::Status: status_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Status<S> {
diff --git a/crates/jacquard-api/src/app_bsky/ageassurance.rs b/crates/jacquard-api/src/app_bsky/ageassurance.rs
index 8386aaf3..bd0e79df 100644
--- a/crates/jacquard-api/src/app_bsky/ageassurance.rs
+++ b/crates/jacquard-api/src/app_bsky/ageassurance.rs
@@ -1460,49 +1460,49 @@ pub mod config_region_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Rules;
         type CountryCode;
+        type Rules;
         type MinAccessAge;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Rules = Unset;
         type CountryCode = Unset;
+        type Rules = Unset;
         type MinAccessAge = Unset;
     }
-    ///State transition - sets the `rules` field to Set
-    pub struct SetRules<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRules<St> {}
-    impl<St: State> State for SetRules<St> {
-        type Rules = Set<members::rules>;
-        type CountryCode = St::CountryCode;
-        type MinAccessAge = St::MinAccessAge;
-    }
     ///State transition - sets the `country_code` field to Set
     pub struct SetCountryCode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCountryCode<St> {}
     impl<St: State> State for SetCountryCode<St> {
-        type Rules = St::Rules;
         type CountryCode = Set<members::country_code>;
+        type Rules = St::Rules;
+        type MinAccessAge = St::MinAccessAge;
+    }
+    ///State transition - sets the `rules` field to Set
+    pub struct SetRules<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRules<St> {}
+    impl<St: State> State for SetRules<St> {
+        type CountryCode = St::CountryCode;
+        type Rules = Set<members::rules>;
         type MinAccessAge = St::MinAccessAge;
     }
     ///State transition - sets the `min_access_age` field to Set
     pub struct SetMinAccessAge<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMinAccessAge<St> {}
     impl<St: State> State for SetMinAccessAge<St> {
-        type Rules = St::Rules;
         type CountryCode = St::CountryCode;
+        type Rules = St::Rules;
         type MinAccessAge = Set<members::min_access_age>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `rules` field
-        pub struct rules(());
         ///Marker type for the `country_code` field
         pub struct country_code(());
+        ///Marker type for the `rules` field
+        pub struct rules(());
         ///Marker type for the `min_access_age` field
         pub struct min_access_age(());
     }
@@ -1606,8 +1606,8 @@ where
 impl<S: BosStr, St> ConfigRegionBuilder<S, St>
 where
     St: config_region_state::State,
-    St::Rules: config_region_state::IsSet,
     St::CountryCode: config_region_state::IsSet,
+    St::Rules: config_region_state::IsSet,
     St::MinAccessAge: config_region_state::IsSet,
 {
     /// Build the final struct.
@@ -2058,37 +2058,37 @@ pub mod config_region_rule_if_assured_over_age_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Age;
         type Access;
+        type Age;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Age = Unset;
         type Access = Unset;
-    }
-    ///State transition - sets the `age` field to Set
-    pub struct SetAge<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAge<St> {}
-    impl<St: State> State for SetAge<St> {
-        type Age = Set<members::age>;
-        type Access = St::Access;
+        type Age = Unset;
     }
     ///State transition - sets the `access` field to Set
     pub struct SetAccess<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAccess<St> {}
     impl<St: State> State for SetAccess<St> {
-        type Age = St::Age;
         type Access = Set<members::access>;
+        type Age = St::Age;
+    }
+    ///State transition - sets the `age` field to Set
+    pub struct SetAge<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAge<St> {}
+    impl<St: State> State for SetAge<St> {
+        type Access = St::Access;
+        type Age = Set<members::age>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `age` field
-        pub struct age(());
         ///Marker type for the `access` field
         pub struct access(());
+        ///Marker type for the `age` field
+        pub struct age(());
     }
 }
 
@@ -2175,8 +2175,8 @@ where
 impl<S: BosStr, St> ConfigRegionRuleIfAssuredOverAgeBuilder<S, St>
 where
     St: config_region_rule_if_assured_over_age_state::State,
-    St::Age: config_region_rule_if_assured_over_age_state::IsSet,
     St::Access: config_region_rule_if_assured_over_age_state::IsSet,
+    St::Age: config_region_rule_if_assured_over_age_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ConfigRegionRuleIfAssuredOverAge<S> {
@@ -2360,37 +2360,37 @@ pub mod config_region_rule_if_declared_over_age_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Age;
         type Access;
+        type Age;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Age = Unset;
         type Access = Unset;
-    }
-    ///State transition - sets the `age` field to Set
-    pub struct SetAge<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAge<St> {}
-    impl<St: State> State for SetAge<St> {
-        type Age = Set<members::age>;
-        type Access = St::Access;
+        type Age = Unset;
     }
     ///State transition - sets the `access` field to Set
     pub struct SetAccess<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAccess<St> {}
     impl<St: State> State for SetAccess<St> {
-        type Age = St::Age;
         type Access = Set<members::access>;
+        type Age = St::Age;
+    }
+    ///State transition - sets the `age` field to Set
+    pub struct SetAge<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAge<St> {}
+    impl<St: State> State for SetAge<St> {
+        type Access = St::Access;
+        type Age = Set<members::age>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `age` field
-        pub struct age(());
         ///Marker type for the `access` field
         pub struct access(());
+        ///Marker type for the `age` field
+        pub struct age(());
     }
 }
 
@@ -2477,8 +2477,8 @@ where
 impl<S: BosStr, St> ConfigRegionRuleIfDeclaredOverAgeBuilder<S, St>
 where
     St: config_region_rule_if_declared_over_age_state::State,
-    St::Age: config_region_rule_if_declared_over_age_state::IsSet,
     St::Access: config_region_rule_if_declared_over_age_state::IsSet,
+    St::Age: config_region_rule_if_declared_over_age_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ConfigRegionRuleIfDeclaredOverAge<S> {
@@ -2662,85 +2662,85 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type AttemptId;
-        type Access;
         type CountryCode;
         type Status;
+        type CreatedAt;
+        type Access;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type AttemptId = Unset;
-        type Access = Unset;
         type CountryCode = Unset;
         type Status = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type AttemptId = St::AttemptId;
-        type Access = St::Access;
-        type CountryCode = St::CountryCode;
-        type Status = St::Status;
+        type CreatedAt = Unset;
+        type Access = Unset;
     }
     ///State transition - sets the `attempt_id` field to Set
     pub struct SetAttemptId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAttemptId<St> {}
     impl<St: State> State for SetAttemptId<St> {
-        type CreatedAt = St::CreatedAt;
         type AttemptId = Set<members::attempt_id>;
-        type Access = St::Access;
         type CountryCode = St::CountryCode;
         type Status = St::Status;
-    }
-    ///State transition - sets the `access` field to Set
-    pub struct SetAccess<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAccess<St> {}
-    impl<St: State> State for SetAccess<St> {
         type CreatedAt = St::CreatedAt;
-        type AttemptId = St::AttemptId;
-        type Access = Set<members::access>;
-        type CountryCode = St::CountryCode;
-        type Status = St::Status;
+        type Access = St::Access;
     }
     ///State transition - sets the `country_code` field to Set
     pub struct SetCountryCode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCountryCode<St> {}
     impl<St: State> State for SetCountryCode<St> {
-        type CreatedAt = St::CreatedAt;
         type AttemptId = St::AttemptId;
-        type Access = St::Access;
         type CountryCode = Set<members::country_code>;
         type Status = St::Status;
+        type CreatedAt = St::CreatedAt;
+        type Access = St::Access;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
+        type AttemptId = St::AttemptId;
+        type CountryCode = St::CountryCode;
+        type Status = Set<members::status>;
         type CreatedAt = St::CreatedAt;
+        type Access = St::Access;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type AttemptId = St::AttemptId;
+        type CountryCode = St::CountryCode;
+        type Status = St::Status;
+        type CreatedAt = Set<members::created_at>;
         type Access = St::Access;
+    }
+    ///State transition - sets the `access` field to Set
+    pub struct SetAccess<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAccess<St> {}
+    impl<St: State> State for SetAccess<St> {
+        type AttemptId = St::AttemptId;
         type CountryCode = St::CountryCode;
-        type Status = Set<members::status>;
+        type Status = St::Status;
+        type CreatedAt = St::CreatedAt;
+        type Access = Set<members::access>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `attempt_id` field
         pub struct attempt_id(());
-        ///Marker type for the `access` field
-        pub struct access(());
         ///Marker type for the `country_code` field
         pub struct country_code(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `access` field
+        pub struct access(());
     }
 }
 
@@ -2957,11 +2957,11 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::CreatedAt: event_state::IsSet,
     St::AttemptId: event_state::IsSet,
-    St::Access: event_state::IsSet,
     St::CountryCode: event_state::IsSet,
     St::Status: event_state::IsSet,
+    St::CreatedAt: event_state::IsSet,
+    St::Access: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/app_bsky/bookmark.rs b/crates/jacquard-api/src/app_bsky/bookmark.rs
index 867072a8..b01a9858 100644
--- a/crates/jacquard-api/src/app_bsky/bookmark.rs
+++ b/crates/jacquard-api/src/app_bsky/bookmark.rs
@@ -286,37 +286,37 @@ pub mod bookmark_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type Item;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type Item = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type Item = St::Item;
+        type Subject = Unset;
     }
     ///State transition - sets the `item` field to Set
     pub struct SetItem<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetItem<St> {}
     impl<St: State> State for SetItem<St> {
-        type Subject = St::Subject;
         type Item = Set<members::item>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Item = St::Item;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `item` field
         pub struct item(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -399,8 +399,8 @@ where
 impl<S: BosStr, St> BookmarkViewBuilder<S, St>
 where
     St: bookmark_view_state::State,
-    St::Subject: bookmark_view_state::IsSet,
     St::Item: bookmark_view_state::IsSet,
+    St::Subject: bookmark_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BookmarkView<S> {
diff --git a/crates/jacquard-api/src/app_bsky/contact.rs b/crates/jacquard-api/src/app_bsky/contact.rs
index c16f9dc6..37e7b907 100644
--- a/crates/jacquard-api/src/app_bsky/contact.rs
+++ b/crates/jacquard-api/src/app_bsky/contact.rs
@@ -158,37 +158,37 @@ pub mod match_and_contact_index_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Match;
         type ContactIndex;
+        type Match;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Match = Unset;
         type ContactIndex = Unset;
-    }
-    ///State transition - sets the `match` field to Set
-    pub struct SetMatch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMatch<St> {}
-    impl<St: State> State for SetMatch<St> {
-        type Match = Set<members::r#match>;
-        type ContactIndex = St::ContactIndex;
+        type Match = Unset;
     }
     ///State transition - sets the `contact_index` field to Set
     pub struct SetContactIndex<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContactIndex<St> {}
     impl<St: State> State for SetContactIndex<St> {
-        type Match = St::Match;
         type ContactIndex = Set<members::contact_index>;
+        type Match = St::Match;
+    }
+    ///State transition - sets the `match` field to Set
+    pub struct SetMatch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMatch<St> {}
+    impl<St: State> State for SetMatch<St> {
+        type ContactIndex = St::ContactIndex;
+        type Match = Set<members::r#match>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `match` field
-        pub struct r#match(());
         ///Marker type for the `contact_index` field
         pub struct contact_index(());
+        ///Marker type for the `match` field
+        pub struct r#match(());
     }
 }
 
@@ -267,8 +267,8 @@ where
 impl<S: BosStr, St> MatchAndContactIndexBuilder<S, St>
 where
     St: match_and_contact_index_state::State,
-    St::Match: match_and_contact_index_state::IsSet,
     St::ContactIndex: match_and_contact_index_state::IsSet,
+    St::Match: match_and_contact_index_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MatchAndContactIndex<S> {
@@ -435,37 +435,37 @@ pub mod notification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type To;
         type From;
+        type To;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type To = Unset;
         type From = Unset;
-    }
-    ///State transition - sets the `to` field to Set
-    pub struct SetTo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTo<St> {}
-    impl<St: State> State for SetTo<St> {
-        type To = Set<members::to>;
-        type From = St::From;
+        type To = Unset;
     }
     ///State transition - sets the `from` field to Set
     pub struct SetFrom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFrom<St> {}
     impl<St: State> State for SetFrom<St> {
-        type To = St::To;
         type From = Set<members::from>;
+        type To = St::To;
+    }
+    ///State transition - sets the `to` field to Set
+    pub struct SetTo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTo<St> {}
+    impl<St: State> State for SetTo<St> {
+        type From = St::From;
+        type To = Set<members::to>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `to` field
-        pub struct to(());
         ///Marker type for the `from` field
         pub struct from(());
+        ///Marker type for the `to` field
+        pub struct to(());
     }
 }
 
@@ -535,8 +535,8 @@ where
 impl<S: BosStr, St> NotificationBuilder<S, St>
 where
     St: notification_state::State,
-    St::To: notification_state::IsSet,
     St::From: notification_state::IsSet,
+    St::To: notification_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Notification<S> {
diff --git a/crates/jacquard-api/src/app_bsky/contact/send_notification.rs b/crates/jacquard-api/src/app_bsky/contact/send_notification.rs
index ee78c343..a52afc9a 100644
--- a/crates/jacquard-api/src/app_bsky/contact/send_notification.rs
+++ b/crates/jacquard-api/src/app_bsky/contact/send_notification.rs
@@ -74,37 +74,37 @@ pub mod send_notification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type From;
         type To;
+        type From;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type From = Unset;
         type To = Unset;
-    }
-    ///State transition - sets the `from` field to Set
-    pub struct SetFrom<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFrom<St> {}
-    impl<St: State> State for SetFrom<St> {
-        type From = Set<members::from>;
-        type To = St::To;
+        type From = Unset;
     }
     ///State transition - sets the `to` field to Set
     pub struct SetTo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTo<St> {}
     impl<St: State> State for SetTo<St> {
-        type From = St::From;
         type To = Set<members::to>;
+        type From = St::From;
+    }
+    ///State transition - sets the `from` field to Set
+    pub struct SetFrom<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFrom<St> {}
+    impl<St: State> State for SetFrom<St> {
+        type To = St::To;
+        type From = Set<members::from>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `from` field
-        pub struct from(());
         ///Marker type for the `to` field
         pub struct to(());
+        ///Marker type for the `from` field
+        pub struct from(());
     }
 }
 
@@ -174,8 +174,8 @@ where
 impl<S: BosStr, St> SendNotificationBuilder<S, St>
 where
     St: send_notification_state::State,
-    St::From: send_notification_state::IsSet,
     St::To: send_notification_state::IsSet,
+    St::From: send_notification_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SendNotification<S> {
diff --git a/crates/jacquard-api/src/app_bsky/draft.rs b/crates/jacquard-api/src/app_bsky/draft.rs
index c1addbb7..548a0035 100644
--- a/crates/jacquard-api/src/app_bsky/draft.rs
+++ b/crates/jacquard-api/src/app_bsky/draft.rs
@@ -1800,66 +1800,66 @@ pub mod draft_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Id;
-        type Draft;
         type UpdatedAt;
+        type Draft;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Id = Unset;
-        type Draft = Unset;
         type UpdatedAt = Unset;
+        type Draft = Unset;
+        type Id = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Id = St::Id;
-        type Draft = St::Draft;
         type UpdatedAt = St::UpdatedAt;
+        type Draft = St::Draft;
+        type Id = St::Id;
     }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
         type CreatedAt = St::CreatedAt;
-        type Id = Set<members::id>;
+        type UpdatedAt = Set<members::updated_at>;
         type Draft = St::Draft;
-        type UpdatedAt = St::UpdatedAt;
+        type Id = St::Id;
     }
     ///State transition - sets the `draft` field to Set
     pub struct SetDraft<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDraft<St> {}
     impl<St: State> State for SetDraft<St> {
         type CreatedAt = St::CreatedAt;
-        type Id = St::Id;
-        type Draft = Set<members::draft>;
         type UpdatedAt = St::UpdatedAt;
+        type Draft = Set<members::draft>;
+        type Id = St::Id;
     }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
         type CreatedAt = St::CreatedAt;
-        type Id = St::Id;
+        type UpdatedAt = St::UpdatedAt;
         type Draft = St::Draft;
-        type UpdatedAt = Set<members::updated_at>;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `id` field
-        pub struct id(());
-        ///Marker type for the `draft` field
-        pub struct draft(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
+        ///Marker type for the `draft` field
+        pub struct draft(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -1968,9 +1968,9 @@ impl<S: BosStr, St> DraftViewBuilder<S, St>
 where
     St: draft_view_state::State,
     St::CreatedAt: draft_view_state::IsSet,
-    St::Id: draft_view_state::IsSet,
-    St::Draft: draft_view_state::IsSet,
     St::UpdatedAt: draft_view_state::IsSet,
+    St::Draft: draft_view_state::IsSet,
+    St::Id: draft_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DraftView<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed.rs b/crates/jacquard-api/src/app_bsky/embed.rs
index 93a84294..b1efa9ff 100644
--- a/crates/jacquard-api/src/app_bsky/embed.rs
+++ b/crates/jacquard-api/src/app_bsky/embed.rs
@@ -86,37 +86,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -186,8 +186,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Width: aspect_ratio_state::IsSet,
     St::Height: aspect_ratio_state::IsSet,
+    St::Width: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed/external.rs b/crates/jacquard-api/src/app_bsky/embed/external.rs
index db0d1122..90b61b98 100644
--- a/crates/jacquard-api/src/app_bsky/embed/external.rs
+++ b/crates/jacquard-api/src/app_bsky/embed/external.rs
@@ -693,50 +693,50 @@ pub mod view_external_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Uri;
-        type Description;
         type Title;
+        type Description;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Uri = Unset;
-        type Description = Unset;
         type Title = Unset;
+        type Description = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Uri = Set<members::uri>;
-        type Description = St::Description;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Uri = St::Uri;
-        type Description = Set<members::description>;
         type Title = St::Title;
+        type Description = St::Description;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
         type Uri = St::Uri;
-        type Description = St::Description;
         type Title = Set<members::title>;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Uri = St::Uri;
+        type Title = St::Title;
+        type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `description` field
+        pub struct description(());
     }
 }
 
@@ -839,8 +839,8 @@ impl<S: BosStr, St> ViewExternalBuilder<S, St>
 where
     St: view_external_state::State,
     St::Uri: view_external_state::IsSet,
-    St::Description: view_external_state::IsSet,
     St::Title: view_external_state::IsSet,
+    St::Description: view_external_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewExternal<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed/images.rs b/crates/jacquard-api/src/app_bsky/embed/images.rs
index 1ce4ed00..2f337f42 100644
--- a/crates/jacquard-api/src/app_bsky/embed/images.rs
+++ b/crates/jacquard-api/src/app_bsky/embed/images.rs
@@ -206,37 +206,37 @@ pub mod image_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type Alt;
+        type Image;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type Alt = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type Alt = St::Alt;
+        type Image = Unset;
     }
     ///State transition - sets the `alt` field to Set
     pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlt<St> {}
     impl<St: State> State for SetAlt<St> {
-        type Image = St::Image;
         type Alt = Set<members::alt>;
+        type Image = St::Image;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type Alt = St::Alt;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `alt` field
         pub struct alt(());
+        ///Marker type for the `image` field
+        pub struct image(());
     }
 }
 
@@ -319,8 +319,8 @@ where
 impl<S: BosStr, St> ImageBuilder<S, St>
 where
     St: image_state::State,
-    St::Image: image_state::IsSet,
     St::Alt: image_state::IsSet,
+    St::Image: image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Image<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed/record.rs b/crates/jacquard-api/src/app_bsky/embed/record.rs
index 7e546ef5..f5d3f428 100644
--- a/crates/jacquard-api/src/app_bsky/embed/record.rs
+++ b/crates/jacquard-api/src/app_bsky/embed/record.rs
@@ -706,51 +706,51 @@ pub mod view_blocked_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Blocked;
         type Author;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Blocked = Unset;
         type Author = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Blocked = St::Blocked;
-        type Author = St::Author;
+        type Uri = Unset;
     }
     ///State transition - sets the `blocked` field to Set
     pub struct SetBlocked<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlocked<St> {}
     impl<St: State> State for SetBlocked<St> {
-        type Uri = St::Uri;
         type Blocked = Set<members::blocked>;
         type Author = St::Author;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Uri = St::Uri;
         type Blocked = St::Blocked;
         type Author = Set<members::author>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Blocked = St::Blocked;
+        type Author = St::Author;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `blocked` field
         pub struct blocked(());
         ///Marker type for the `author` field
         pub struct author(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -839,9 +839,9 @@ where
 impl<S: BosStr, St> ViewBlockedBuilder<S, St>
 where
     St: view_blocked_state::State,
-    St::Uri: view_blocked_state::IsSet,
     St::Blocked: view_blocked_state::IsSet,
     St::Author: view_blocked_state::IsSet,
+    St::Uri: view_blocked_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewBlocked<S> {
@@ -1146,9 +1146,9 @@ pub mod view_record_state {
     pub trait State: sealed::Sealed {
         type Cid;
         type Author;
+        type IndexedAt;
         type Value;
         type Uri;
-        type IndexedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -1156,9 +1156,9 @@ pub mod view_record_state {
     impl State for Empty {
         type Cid = Unset;
         type Author = Unset;
+        type IndexedAt = Unset;
         type Value = Unset;
         type Uri = Unset;
-        type IndexedAt = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
@@ -1166,9 +1166,9 @@ pub mod view_record_state {
     impl<St: State> State for SetCid<St> {
         type Cid = Set<members::cid>;
         type Author = St::Author;
+        type IndexedAt = St::IndexedAt;
         type Value = St::Value;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
@@ -1176,9 +1176,19 @@ pub mod view_record_state {
     impl<St: State> State for SetAuthor<St> {
         type Cid = St::Cid;
         type Author = Set<members::author>;
+        type IndexedAt = St::IndexedAt;
+        type Value = St::Value;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Cid = St::Cid;
+        type Author = St::Author;
+        type IndexedAt = Set<members::indexed_at>;
         type Value = St::Value;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
@@ -1186,9 +1196,9 @@ pub mod view_record_state {
     impl<St: State> State for SetValue<St> {
         type Cid = St::Cid;
         type Author = St::Author;
+        type IndexedAt = St::IndexedAt;
         type Value = Set<members::value>;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
@@ -1196,19 +1206,9 @@ pub mod view_record_state {
     impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
         type Author = St::Author;
-        type Value = St::Value;
-        type Uri = Set<members::uri>;
         type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Cid = St::Cid;
-        type Author = St::Author;
         type Value = St::Value;
-        type Uri = St::Uri;
-        type IndexedAt = Set<members::indexed_at>;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -1217,12 +1217,12 @@ pub mod view_record_state {
         pub struct cid(());
         ///Marker type for the `author` field
         pub struct author(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `value` field
         pub struct value(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
     }
 }
 
@@ -1444,9 +1444,9 @@ where
     St: view_record_state::State,
     St::Cid: view_record_state::IsSet,
     St::Author: view_record_state::IsSet,
+    St::IndexedAt: view_record_state::IsSet,
     St::Value: view_record_state::IsSet,
     St::Uri: view_record_state::IsSet,
-    St::IndexedAt: view_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewRecord<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs b/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs
index 515d1eca..7e77f49b 100644
--- a/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs
+++ b/crates/jacquard-api/src/app_bsky/embed/record_with_media.rs
@@ -117,37 +117,37 @@ pub mod record_with_media_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Record;
         type Media;
+        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Record = Unset;
         type Media = Unset;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Record = Set<members::record>;
-        type Media = St::Media;
+        type Record = Unset;
     }
     ///State transition - sets the `media` field to Set
     pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMedia<St> {}
     impl<St: State> State for SetMedia<St> {
-        type Record = St::Record;
         type Media = Set<members::media>;
+        type Record = St::Record;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Media = St::Media;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `record` field
-        pub struct record(());
         ///Marker type for the `media` field
         pub struct media(());
+        ///Marker type for the `record` field
+        pub struct record(());
     }
 }
 
@@ -217,8 +217,8 @@ where
 impl<S: BosStr, St> RecordWithMediaBuilder<S, St>
 where
     St: record_with_media_state::State,
-    St::Record: record_with_media_state::IsSet,
     St::Media: record_with_media_state::IsSet,
+    St::Record: record_with_media_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RecordWithMedia<S> {
@@ -331,37 +331,37 @@ pub mod view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Media;
         type Record;
+        type Media;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Media = Unset;
         type Record = Unset;
-    }
-    ///State transition - sets the `media` field to Set
-    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMedia<St> {}
-    impl<St: State> State for SetMedia<St> {
-        type Media = Set<members::media>;
-        type Record = St::Record;
+        type Media = Unset;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Media = St::Media;
         type Record = Set<members::record>;
+        type Media = St::Media;
+    }
+    ///State transition - sets the `media` field to Set
+    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMedia<St> {}
+    impl<St: State> State for SetMedia<St> {
+        type Record = St::Record;
+        type Media = Set<members::media>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `media` field
-        pub struct media(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `media` field
+        pub struct media(());
     }
 }
 
@@ -431,8 +431,8 @@ where
 impl<S: BosStr, St> ViewBuilder<S, St>
 where
     St: view_state::State,
-    St::Media: view_state::IsSet,
     St::Record: view_state::IsSet,
+    St::Media: view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> View<S> {
diff --git a/crates/jacquard-api/src/app_bsky/embed/video.rs b/crates/jacquard-api/src/app_bsky/embed/video.rs
index ff4a74cb..836f7aba 100644
--- a/crates/jacquard-api/src/app_bsky/embed/video.rs
+++ b/crates/jacquard-api/src/app_bsky/embed/video.rs
@@ -423,37 +423,37 @@ pub mod caption_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Lang;
         type File;
+        type Lang;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Lang = Unset;
         type File = Unset;
-    }
-    ///State transition - sets the `lang` field to Set
-    pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLang<St> {}
-    impl<St: State> State for SetLang<St> {
-        type Lang = Set<members::lang>;
-        type File = St::File;
+        type Lang = Unset;
     }
     ///State transition - sets the `file` field to Set
     pub struct SetFile<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFile<St> {}
     impl<St: State> State for SetFile<St> {
-        type Lang = St::Lang;
         type File = Set<members::file>;
+        type Lang = St::Lang;
+    }
+    ///State transition - sets the `lang` field to Set
+    pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLang<St> {}
+    impl<St: State> State for SetLang<St> {
+        type File = St::File;
+        type Lang = Set<members::lang>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `lang` field
-        pub struct lang(());
         ///Marker type for the `file` field
         pub struct file(());
+        ///Marker type for the `lang` field
+        pub struct lang(());
     }
 }
 
@@ -523,8 +523,8 @@ where
 impl<S: BosStr, St> CaptionBuilder<S, St>
 where
     St: caption_state::State,
-    St::Lang: caption_state::IsSet,
     St::File: caption_state::IsSet,
+    St::Lang: caption_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Caption<S> {
diff --git a/crates/jacquard-api/src/app_bsky/feed.rs b/crates/jacquard-api/src/app_bsky/feed.rs
index a9e42654..43ad3a93 100644
--- a/crates/jacquard-api/src/app_bsky/feed.rs
+++ b/crates/jacquard-api/src/app_bsky/feed.rs
@@ -2466,105 +2466,105 @@ pub mod generator_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Uri;
-        type DisplayName;
         type IndexedAt;
-        type Creator;
+        type Did;
         type Cid;
+        type Creator;
+        type DisplayName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Uri = Unset;
-        type DisplayName = Unset;
         type IndexedAt = Unset;
-        type Creator = Unset;
+        type Did = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Uri = St::Uri;
-        type DisplayName = St::DisplayName;
-        type IndexedAt = St::IndexedAt;
-        type Creator = St::Creator;
-        type Cid = St::Cid;
+        type Creator = Unset;
+        type DisplayName = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Did = St::Did;
         type Uri = Set<members::uri>;
-        type DisplayName = St::DisplayName;
         type IndexedAt = St::IndexedAt;
-        type Creator = St::Creator;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
         type Did = St::Did;
-        type Uri = St::Uri;
-        type DisplayName = Set<members::display_name>;
-        type IndexedAt = St::IndexedAt;
-        type Creator = St::Creator;
         type Cid = St::Cid;
+        type Creator = St::Creator;
+        type DisplayName = St::DisplayName;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Did = St::Did;
         type Uri = St::Uri;
-        type DisplayName = St::DisplayName;
         type IndexedAt = Set<members::indexed_at>;
-        type Creator = St::Creator;
+        type Did = St::Did;
         type Cid = St::Cid;
+        type Creator = St::Creator;
+        type DisplayName = St::DisplayName;
     }
-    ///State transition - sets the `creator` field to Set
-    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreator<St> {}
-    impl<St: State> State for SetCreator<St> {
-        type Did = St::Did;
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
         type Uri = St::Uri;
-        type DisplayName = St::DisplayName;
         type IndexedAt = St::IndexedAt;
-        type Creator = Set<members::creator>;
+        type Did = Set<members::did>;
         type Cid = St::Cid;
+        type Creator = St::Creator;
+        type DisplayName = St::DisplayName;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type Did = St::Did;
+        type Cid = Set<members::cid>;
+        type Creator = St::Creator;
+        type DisplayName = St::DisplayName;
+    }
+    ///State transition - sets the `creator` field to Set
+    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreator<St> {}
+    impl<St: State> State for SetCreator<St> {
         type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
+        type Did = St::Did;
+        type Cid = St::Cid;
+        type Creator = Set<members::creator>;
         type DisplayName = St::DisplayName;
+    }
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
+        type Uri = St::Uri;
         type IndexedAt = St::IndexedAt;
+        type Did = St::Did;
+        type Cid = St::Cid;
         type Creator = St::Creator;
-        type Cid = Set<members::cid>;
+        type DisplayName = Set<members::display_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `creator` field
-        pub struct creator(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `creator` field
+        pub struct creator(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
     }
 }
 
@@ -2856,12 +2856,12 @@ impl<S: BosStr, St: generator_view_state::State> GeneratorViewBuilder<S, St> {
 impl<S: BosStr, St> GeneratorViewBuilder<S, St>
 where
     St: generator_view_state::State,
-    St::Did: generator_view_state::IsSet,
     St::Uri: generator_view_state::IsSet,
-    St::DisplayName: generator_view_state::IsSet,
     St::IndexedAt: generator_view_state::IsSet,
-    St::Creator: generator_view_state::IsSet,
+    St::Did: generator_view_state::IsSet,
     St::Cid: generator_view_state::IsSet,
+    St::Creator: generator_view_state::IsSet,
+    St::DisplayName: generator_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GeneratorView<S> {
@@ -2918,37 +2918,37 @@ pub mod not_found_post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type NotFound;
         type Uri;
+        type NotFound;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type NotFound = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `not_found` field to Set
-    pub struct SetNotFound<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotFound<St> {}
-    impl<St: State> State for SetNotFound<St> {
-        type NotFound = Set<members::not_found>;
-        type Uri = St::Uri;
+        type NotFound = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type NotFound = St::NotFound;
         type Uri = Set<members::uri>;
+        type NotFound = St::NotFound;
+    }
+    ///State transition - sets the `not_found` field to Set
+    pub struct SetNotFound<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotFound<St> {}
+    impl<St: State> State for SetNotFound<St> {
+        type Uri = St::Uri;
+        type NotFound = Set<members::not_found>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `not_found` field
-        pub struct not_found(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `not_found` field
+        pub struct not_found(());
     }
 }
 
@@ -3018,8 +3018,8 @@ where
 impl<S: BosStr, St> NotFoundPostBuilder<S, St>
 where
     St: not_found_post_state::State,
-    St::NotFound: not_found_post_state::IsSet,
     St::Uri: not_found_post_state::IsSet,
+    St::NotFound: not_found_post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotFoundPost<S> {
@@ -3052,85 +3052,85 @@ pub mod post_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Author;
-        type Cid;
+        type IndexedAt;
         type Uri;
         type Record;
-        type IndexedAt;
+        type Cid;
+        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Author = Unset;
-        type Cid = Unset;
+        type IndexedAt = Unset;
         type Uri = Unset;
         type Record = Unset;
-        type IndexedAt = Unset;
+        type Cid = Unset;
+        type Author = Unset;
     }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Author = Set<members::author>;
-        type Cid = St::Cid;
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
         type Record = St::Record;
-        type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+        type Cid = St::Cid;
         type Author = St::Author;
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
-        type Record = St::Record;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Author = St::Author;
-        type Cid = St::Cid;
+        type IndexedAt = St::IndexedAt;
         type Uri = Set<members::uri>;
         type Record = St::Record;
-        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Author = St::Author;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Author = St::Author;
-        type Cid = St::Cid;
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
         type Record = Set<members::record>;
-        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Author = St::Author;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Record = St::Record;
+        type Cid = Set<members::cid>;
         type Author = St::Author;
-        type Cid = St::Cid;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
         type Record = St::Record;
-        type IndexedAt = Set<members::indexed_at>;
+        type Cid = St::Cid;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `author` field
-        pub struct author(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `record` field
         pub struct record(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `author` field
+        pub struct author(());
     }
 }
 
@@ -3422,11 +3422,11 @@ impl<S: BosStr, St: post_view_state::State> PostViewBuilder<S, St> {
 impl<S: BosStr, St> PostViewBuilder<S, St>
 where
     St: post_view_state::State,
-    St::Author: post_view_state::IsSet,
-    St::Cid: post_view_state::IsSet,
+    St::IndexedAt: post_view_state::IsSet,
     St::Uri: post_view_state::IsSet,
     St::Record: post_view_state::IsSet,
-    St::IndexedAt: post_view_state::IsSet,
+    St::Cid: post_view_state::IsSet,
+    St::Author: post_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PostView<S> {
diff --git a/crates/jacquard-api/src/app_bsky/feed/get_likes.rs b/crates/jacquard-api/src/app_bsky/feed/get_likes.rs
index 95471c81..37791e24 100644
--- a/crates/jacquard-api/src/app_bsky/feed/get_likes.rs
+++ b/crates/jacquard-api/src/app_bsky/feed/get_likes.rs
@@ -115,51 +115,51 @@ pub mod like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Actor;
         type IndexedAt;
         type CreatedAt;
+        type Actor;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Actor = Unset;
         type IndexedAt = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `actor` field to Set
-    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActor<St> {}
-    impl<St: State> State for SetActor<St> {
-        type Actor = Set<members::actor>;
-        type IndexedAt = St::IndexedAt;
-        type CreatedAt = St::CreatedAt;
+        type Actor = Unset;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Actor = St::Actor;
         type IndexedAt = Set<members::indexed_at>;
         type CreatedAt = St::CreatedAt;
+        type Actor = St::Actor;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Actor = St::Actor;
         type IndexedAt = St::IndexedAt;
         type CreatedAt = Set<members::created_at>;
+        type Actor = St::Actor;
+    }
+    ///State transition - sets the `actor` field to Set
+    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActor<St> {}
+    impl<St: State> State for SetActor<St> {
+        type IndexedAt = St::IndexedAt;
+        type CreatedAt = St::CreatedAt;
+        type Actor = Set<members::actor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `actor` field
-        pub struct actor(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `actor` field
+        pub struct actor(());
     }
 }
 
@@ -248,9 +248,9 @@ where
 impl<S: BosStr, St> LikeBuilder<S, St>
 where
     St: like_state::State,
-    St::Actor: like_state::IsSet,
     St::IndexedAt: like_state::IsSet,
     St::CreatedAt: like_state::IsSet,
+    St::Actor: like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Like<S> {
diff --git a/crates/jacquard-api/src/app_bsky/feed/post.rs b/crates/jacquard-api/src/app_bsky/feed/post.rs
index 2318fbdf..958a8ced 100644
--- a/crates/jacquard-api/src/app_bsky/feed/post.rs
+++ b/crates/jacquard-api/src/app_bsky/feed/post.rs
@@ -302,51 +302,51 @@ pub mod entity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
-        type Index;
         type Value;
+        type Index;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
-        type Index = Unset;
         type Value = Unset;
+        type Index = Unset;
+        type Type = Unset;
     }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Value = Set<members::value>;
         type Index = St::Index;
-        type Value = St::Value;
+        type Type = St::Type;
     }
     ///State transition - sets the `index` field to Set
     pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndex<St> {}
     impl<St: State> State for SetIndex<St> {
-        type Type = St::Type;
-        type Index = Set<members::index>;
         type Value = St::Value;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
+        type Index = Set<members::index>;
         type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Value = St::Value;
         type Index = St::Index;
-        type Value = Set<members::value>;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `value` field
         pub struct value(());
+        ///Marker type for the `index` field
+        pub struct index(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -435,9 +435,9 @@ where
 impl<S: BosStr, St> EntityBuilder<S, St>
 where
     St: entity_state::State,
-    St::Type: entity_state::IsSet,
-    St::Index: entity_state::IsSet,
     St::Value: entity_state::IsSet,
+    St::Index: entity_state::IsSet,
+    St::Type: entity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Entity<S> {
@@ -1111,37 +1111,37 @@ pub mod text_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type End;
         type Start;
+        type End;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type End = Unset;
         type Start = Unset;
-    }
-    ///State transition - sets the `end` field to Set
-    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEnd<St> {}
-    impl<St: State> State for SetEnd<St> {
-        type End = Set<members::end>;
-        type Start = St::Start;
+        type End = Unset;
     }
     ///State transition - sets the `start` field to Set
     pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStart<St> {}
     impl<St: State> State for SetStart<St> {
-        type End = St::End;
         type Start = Set<members::start>;
+        type End = St::End;
+    }
+    ///State transition - sets the `end` field to Set
+    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEnd<St> {}
+    impl<St: State> State for SetEnd<St> {
+        type Start = St::Start;
+        type End = Set<members::end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `end` field
-        pub struct end(());
         ///Marker type for the `start` field
         pub struct start(());
+        ///Marker type for the `end` field
+        pub struct end(());
     }
 }
 
@@ -1211,8 +1211,8 @@ where
 impl<S: BosStr, St> TextSliceBuilder<S, St>
 where
     St: text_slice_state::State,
-    St::End: text_slice_state::IsSet,
     St::Start: text_slice_state::IsSet,
+    St::End: text_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TextSlice<S> {
diff --git a/crates/jacquard-api/src/app_bsky/feed/threadgate.rs b/crates/jacquard-api/src/app_bsky/feed/threadgate.rs
index 1905fccb..618236d6 100644
--- a/crates/jacquard-api/src/app_bsky/feed/threadgate.rs
+++ b/crates/jacquard-api/src/app_bsky/feed/threadgate.rs
@@ -509,37 +509,37 @@ pub mod threadgate_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Post;
         type CreatedAt;
+        type Post;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Post = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `post` field to Set
-    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPost<St> {}
-    impl<St: State> State for SetPost<St> {
-        type Post = Set<members::post>;
-        type CreatedAt = St::CreatedAt;
+        type Post = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Post = St::Post;
         type CreatedAt = Set<members::created_at>;
+        type Post = St::Post;
+    }
+    ///State transition - sets the `post` field to Set
+    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPost<St> {}
+    impl<St: State> State for SetPost<St> {
+        type CreatedAt = St::CreatedAt;
+        type Post = Set<members::post>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `post` field
-        pub struct post(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `post` field
+        pub struct post(());
     }
 }
 
@@ -643,8 +643,8 @@ where
 impl<S: BosStr, St> ThreadgateBuilder<S, St>
 where
     St: threadgate_state::State,
-    St::Post: threadgate_state::IsSet,
     St::CreatedAt: threadgate_state::IsSet,
+    St::Post: threadgate_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Threadgate<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph.rs b/crates/jacquard-api/src/app_bsky/graph.rs
index bf4f022a..6447fc94 100644
--- a/crates/jacquard-api/src/app_bsky/graph.rs
+++ b/crates/jacquard-api/src/app_bsky/graph.rs
@@ -1350,105 +1350,105 @@ pub mod list_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Purpose;
-        type Name;
         type IndexedAt;
-        type Creator;
         type Uri;
+        type Cid;
+        type Name;
+        type Creator;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Purpose = Unset;
-        type Name = Unset;
         type IndexedAt = Unset;
-        type Creator = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Purpose = St::Purpose;
-        type Name = St::Name;
-        type IndexedAt = St::IndexedAt;
-        type Creator = St::Creator;
-        type Uri = St::Uri;
+        type Cid = Unset;
+        type Name = Unset;
+        type Creator = Unset;
     }
     ///State transition - sets the `purpose` field to Set
     pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPurpose<St> {}
     impl<St: State> State for SetPurpose<St> {
-        type Cid = St::Cid;
         type Purpose = Set<members::purpose>;
-        type Name = St::Name;
         type IndexedAt = St::IndexedAt;
-        type Creator = St::Creator;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type Cid = St::Cid;
-        type Purpose = St::Purpose;
-        type Name = Set<members::name>;
-        type IndexedAt = St::IndexedAt;
+        type Name = St::Name;
         type Creator = St::Creator;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Cid = St::Cid;
         type Purpose = St::Purpose;
-        type Name = St::Name;
         type IndexedAt = Set<members::indexed_at>;
-        type Creator = St::Creator;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `creator` field to Set
-    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreator<St> {}
-    impl<St: State> State for SetCreator<St> {
         type Cid = St::Cid;
-        type Purpose = St::Purpose;
         type Name = St::Name;
-        type IndexedAt = St::IndexedAt;
-        type Creator = Set<members::creator>;
-        type Uri = St::Uri;
+        type Creator = St::Creator;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
+        type Purpose = St::Purpose;
+        type IndexedAt = St::IndexedAt;
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
+        type Name = St::Name;
+        type Creator = St::Creator;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Purpose = St::Purpose;
+        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Name = St::Name;
+        type Creator = St::Creator;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Purpose = St::Purpose;
         type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Name = Set<members::name>;
         type Creator = St::Creator;
-        type Uri = Set<members::uri>;
+    }
+    ///State transition - sets the `creator` field to Set
+    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreator<St> {}
+    impl<St: State> State for SetCreator<St> {
+        type Purpose = St::Purpose;
+        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Name = St::Name;
+        type Creator = Set<members::creator>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `purpose` field
         pub struct purpose(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `creator` field
-        pub struct creator(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `creator` field
+        pub struct creator(());
     }
 }
 
@@ -1704,12 +1704,12 @@ impl<S: BosStr, St: list_view_state::State> ListViewBuilder<S, St> {
 impl<S: BosStr, St> ListViewBuilder<S, St>
 where
     St: list_view_state::State,
-    St::Cid: list_view_state::IsSet,
     St::Purpose: list_view_state::IsSet,
-    St::Name: list_view_state::IsSet,
     St::IndexedAt: list_view_state::IsSet,
-    St::Creator: list_view_state::IsSet,
     St::Uri: list_view_state::IsSet,
+    St::Cid: list_view_state::IsSet,
+    St::Name: list_view_state::IsSet,
+    St::Creator: list_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListView<S> {
@@ -1759,67 +1759,67 @@ pub mod list_view_basic_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Purpose;
+        type Name;
         type Uri;
+        type Purpose;
         type Cid;
-        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Purpose = Unset;
+        type Name = Unset;
         type Uri = Unset;
+        type Purpose = Unset;
         type Cid = Unset;
-        type Name = Unset;
     }
-    ///State transition - sets the `purpose` field to Set
-    pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPurpose<St> {}
-    impl<St: State> State for SetPurpose<St> {
-        type Purpose = Set<members::purpose>;
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
         type Uri = St::Uri;
+        type Purpose = St::Purpose;
         type Cid = St::Cid;
-        type Name = St::Name;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Purpose = St::Purpose;
+        type Name = St::Name;
         type Uri = Set<members::uri>;
+        type Purpose = St::Purpose;
         type Cid = St::Cid;
+    }
+    ///State transition - sets the `purpose` field to Set
+    pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPurpose<St> {}
+    impl<St: State> State for SetPurpose<St> {
         type Name = St::Name;
+        type Uri = St::Uri;
+        type Purpose = Set<members::purpose>;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Purpose = St::Purpose;
-        type Uri = St::Uri;
-        type Cid = Set<members::cid>;
         type Name = St::Name;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Purpose = St::Purpose;
         type Uri = St::Uri;
-        type Cid = St::Cid;
-        type Name = Set<members::name>;
+        type Purpose = St::Purpose;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `purpose` field
-        pub struct purpose(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `purpose` field
+        pub struct purpose(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `name` field
-        pub struct name(());
     }
 }
 
@@ -2005,10 +2005,10 @@ impl<S: BosStr, St: list_view_basic_state::State> ListViewBasicBuilder<S, St> {
 impl<S: BosStr, St> ListViewBasicBuilder<S, St>
 where
     St: list_view_basic_state::State,
-    St::Purpose: list_view_basic_state::IsSet,
+    St::Name: list_view_basic_state::IsSet,
     St::Uri: list_view_basic_state::IsSet,
+    St::Purpose: list_view_basic_state::IsSet,
     St::Cid: list_view_basic_state::IsSet,
-    St::Name: list_view_basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListViewBasic<S> {
@@ -2055,37 +2055,37 @@ pub mod not_found_actor_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type NotFound;
         type Actor;
+        type NotFound;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type NotFound = Unset;
         type Actor = Unset;
-    }
-    ///State transition - sets the `not_found` field to Set
-    pub struct SetNotFound<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotFound<St> {}
-    impl<St: State> State for SetNotFound<St> {
-        type NotFound = Set<members::not_found>;
-        type Actor = St::Actor;
+        type NotFound = Unset;
     }
     ///State transition - sets the `actor` field to Set
     pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActor<St> {}
     impl<St: State> State for SetActor<St> {
-        type NotFound = St::NotFound;
         type Actor = Set<members::actor>;
+        type NotFound = St::NotFound;
+    }
+    ///State transition - sets the `not_found` field to Set
+    pub struct SetNotFound<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotFound<St> {}
+    impl<St: State> State for SetNotFound<St> {
+        type Actor = St::Actor;
+        type NotFound = Set<members::not_found>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `not_found` field
-        pub struct not_found(());
         ///Marker type for the `actor` field
         pub struct actor(());
+        ///Marker type for the `not_found` field
+        pub struct not_found(());
     }
 }
 
@@ -2155,8 +2155,8 @@ where
 impl<S: BosStr, St> NotFoundActorBuilder<S, St>
 where
     St: not_found_actor_state::State,
-    St::NotFound: not_found_actor_state::IsSet,
     St::Actor: not_found_actor_state::IsSet,
+    St::NotFound: not_found_actor_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotFoundActor<S> {
@@ -2743,85 +2743,85 @@ pub mod starter_pack_view_basic_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IndexedAt;
-        type Record;
         type Creator;
+        type IndexedAt;
         type Uri;
         type Cid;
+        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IndexedAt = Unset;
-        type Record = Unset;
         type Creator = Unset;
+        type IndexedAt = Unset;
         type Uri = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
-        type Record = St::Record;
-        type Creator = St::Creator;
-        type Uri = St::Uri;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type IndexedAt = St::IndexedAt;
-        type Record = Set<members::record>;
-        type Creator = St::Creator;
-        type Uri = St::Uri;
-        type Cid = St::Cid;
+        type Record = Unset;
     }
     ///State transition - sets the `creator` field to Set
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
+        type Creator = Set<members::creator>;
         type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
         type Record = St::Record;
-        type Creator = Set<members::creator>;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Creator = St::Creator;
+        type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
         type Cid = St::Cid;
+        type Record = St::Record;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type IndexedAt = St::IndexedAt;
-        type Record = St::Record;
         type Creator = St::Creator;
+        type IndexedAt = St::IndexedAt;
         type Uri = Set<members::uri>;
         type Cid = St::Cid;
+        type Record = St::Record;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Creator = St::Creator;
         type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Record = St::Record;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
         type Creator = St::Creator;
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
-        type Cid = Set<members::cid>;
+        type Cid = St::Cid;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
-        ///Marker type for the `record` field
-        pub struct record(());
         ///Marker type for the `creator` field
         pub struct creator(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `record` field
+        pub struct record(());
     }
 }
 
@@ -3031,11 +3031,11 @@ where
 impl<S: BosStr, St> StarterPackViewBasicBuilder<S, St>
 where
     St: starter_pack_view_basic_state::State,
-    St::IndexedAt: starter_pack_view_basic_state::IsSet,
-    St::Record: starter_pack_view_basic_state::IsSet,
     St::Creator: starter_pack_view_basic_state::IsSet,
+    St::IndexedAt: starter_pack_view_basic_state::IsSet,
     St::Uri: starter_pack_view_basic_state::IsSet,
     St::Cid: starter_pack_view_basic_state::IsSet,
+    St::Record: starter_pack_view_basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> StarterPackViewBasic<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph/block.rs b/crates/jacquard-api/src/app_bsky/graph/block.rs
index 94c4a9e3..c126245c 100644
--- a/crates/jacquard-api/src/app_bsky/graph/block.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/block.rs
@@ -113,37 +113,37 @@ pub mod block_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> BlockBuilder<S, St>
 where
     St: block_state::State,
-    St::Subject: block_state::IsSet,
     St::CreatedAt: block_state::IsSet,
+    St::Subject: block_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Block<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph/follow.rs b/crates/jacquard-api/src/app_bsky/graph/follow.rs
index f5eb90a7..e8ed05ee 100644
--- a/crates/jacquard-api/src/app_bsky/graph/follow.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/follow.rs
@@ -115,37 +115,37 @@ pub mod follow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -228,8 +228,8 @@ impl<S: BosStr, St: follow_state::State> FollowBuilder<S, St> {
 impl<S: BosStr, St> FollowBuilder<S, St>
 where
     St: follow_state::State,
-    St::CreatedAt: follow_state::IsSet,
     St::Subject: follow_state::IsSet,
+    St::CreatedAt: follow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Follow<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph/list.rs b/crates/jacquard-api/src/app_bsky/graph/list.rs
index 15ad1ce7..4ff81b97 100644
--- a/crates/jacquard-api/src/app_bsky/graph/list.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/list.rs
@@ -211,51 +211,51 @@ pub mod list_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Name;
         type CreatedAt;
         type Purpose;
-        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Name = Unset;
         type CreatedAt = Unset;
         type Purpose = Unset;
-        type Name = Unset;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+        type Purpose = St::Purpose;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
         type Purpose = St::Purpose;
-        type Name = St::Name;
     }
     ///State transition - sets the `purpose` field to Set
     pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPurpose<St> {}
     impl<St: State> State for SetPurpose<St> {
-        type CreatedAt = St::CreatedAt;
-        type Purpose = Set<members::purpose>;
         type Name = St::Name;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type CreatedAt = St::CreatedAt;
-        type Purpose = St::Purpose;
-        type Name = Set<members::name>;
+        type Purpose = Set<members::purpose>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `purpose` field
         pub struct purpose(());
-        ///Marker type for the `name` field
-        pub struct name(());
     }
 }
 
@@ -407,9 +407,9 @@ where
 impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
+    St::Name: list_state::IsSet,
     St::CreatedAt: list_state::IsSet,
     St::Purpose: list_state::IsSet,
-    St::Name: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph/listitem.rs b/crates/jacquard-api/src/app_bsky/graph/listitem.rs
index 4549c1f1..7a3b7b9f 100644
--- a/crates/jacquard-api/src/app_bsky/graph/listitem.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/listitem.rs
@@ -115,51 +115,51 @@ pub mod listitem_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Subject;
         type List;
         type CreatedAt;
-        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Subject = Unset;
         type List = Unset;
         type CreatedAt = Unset;
-        type Subject = Unset;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
+        type List = St::List;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `list` field to Set
     pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetList<St> {}
     impl<St: State> State for SetList<St> {
+        type Subject = St::Subject;
         type List = Set<members::list>;
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type List = St::List;
-        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type List = St::List;
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `list` field
         pub struct list(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
     }
 }
 
@@ -248,9 +248,9 @@ where
 impl<S: BosStr, St> ListitemBuilder<S, St>
 where
     St: listitem_state::State,
+    St::Subject: listitem_state::IsSet,
     St::List: listitem_state::IsSet,
     St::CreatedAt: listitem_state::IsSet,
-    St::Subject: listitem_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Listitem<S> {
diff --git a/crates/jacquard-api/src/app_bsky/graph/starterpack.rs b/crates/jacquard-api/src/app_bsky/graph/starterpack.rs
index 1b200764..856d52c2 100644
--- a/crates/jacquard-api/src/app_bsky/graph/starterpack.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/starterpack.rs
@@ -432,49 +432,49 @@ pub mod starterpack_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type List;
+        type Name;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type List = Unset;
+        type Name = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type List = St::List;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `list` field to Set
     pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetList<St> {}
     impl<St: State> State for SetList<St> {
-        type Name = St::Name;
         type List = Set<members::list>;
+        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type List = St::List;
+        type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type List = St::List;
+        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `list` field
         pub struct list(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -617,8 +617,8 @@ where
 impl<S: BosStr, St> StarterpackBuilder<S, St>
 where
     St: starterpack_state::State,
-    St::Name: starterpack_state::IsSet,
     St::List: starterpack_state::IsSet,
+    St::Name: starterpack_state::IsSet,
     St::CreatedAt: starterpack_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_bsky/graph/verification.rs b/crates/jacquard-api/src/app_bsky/graph/verification.rs
index d4eb0f82..a3f54b0e 100644
--- a/crates/jacquard-api/src/app_bsky/graph/verification.rs
+++ b/crates/jacquard-api/src/app_bsky/graph/verification.rs
@@ -118,67 +118,67 @@ pub mod verification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type DisplayName;
-        type CreatedAt;
         type Subject;
         type Handle;
+        type DisplayName;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type DisplayName = Unset;
-        type CreatedAt = Unset;
         type Subject = Unset;
         type Handle = Unset;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
-        type DisplayName = Set<members::display_name>;
-        type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-        type Handle = St::Handle;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type DisplayName = St::DisplayName;
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
-        type Handle = St::Handle;
+        type DisplayName = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type DisplayName = St::DisplayName;
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
         type Handle = St::Handle;
+        type DisplayName = St::DisplayName;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
+        type Subject = St::Subject;
+        type Handle = Set<members::handle>;
         type DisplayName = St::DisplayName;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
         type Subject = St::Subject;
-        type Handle = Set<members::handle>;
+        type Handle = St::Handle;
+        type DisplayName = Set<members::display_name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type Handle = St::Handle;
+        type DisplayName = St::DisplayName;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -286,10 +286,10 @@ where
 impl<S: BosStr, St> VerificationBuilder<S, St>
 where
     St: verification_state::State,
-    St::DisplayName: verification_state::IsSet,
-    St::CreatedAt: verification_state::IsSet,
     St::Subject: verification_state::IsSet,
     St::Handle: verification_state::IsSet,
+    St::DisplayName: verification_state::IsSet,
+    St::CreatedAt: verification_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Verification<S> {
diff --git a/crates/jacquard-api/src/app_bsky/labeler.rs b/crates/jacquard-api/src/app_bsky/labeler.rs
index 18d0a29a..3ebf4240 100644
--- a/crates/jacquard-api/src/app_bsky/labeler.rs
+++ b/crates/jacquard-api/src/app_bsky/labeler.rs
@@ -596,8 +596,8 @@ pub mod labeler_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IndexedAt;
         type Uri;
+        type IndexedAt;
         type Creator;
         type Cid;
     }
@@ -605,26 +605,26 @@ pub mod labeler_view_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IndexedAt = Unset;
         type Uri = Unset;
+        type IndexedAt = Unset;
         type Creator = Unset;
         type Cid = Unset;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
-        type Uri = St::Uri;
-        type Creator = St::Creator;
-        type Cid = St::Cid;
-    }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type IndexedAt = St::IndexedAt;
         type Uri = Set<members::uri>;
+        type IndexedAt = St::IndexedAt;
+        type Creator = St::Creator;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
+        type IndexedAt = Set<members::indexed_at>;
         type Creator = St::Creator;
         type Cid = St::Cid;
     }
@@ -632,8 +632,8 @@ pub mod labeler_view_state {
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
-        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type Creator = Set<members::creator>;
         type Cid = St::Cid;
     }
@@ -641,18 +641,18 @@ pub mod labeler_view_state {
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type Creator = St::Creator;
         type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `creator` field
         pub struct creator(());
         ///Marker type for the `cid` field
@@ -817,8 +817,8 @@ impl<S: BosStr, St: labeler_view_state::State> LabelerViewBuilder<S, St> {
 impl<S: BosStr, St> LabelerViewBuilder<S, St>
 where
     St: labeler_view_state::State,
-    St::IndexedAt: labeler_view_state::IsSet,
     St::Uri: labeler_view_state::IsSet,
+    St::IndexedAt: labeler_view_state::IsSet,
     St::Creator: labeler_view_state::IsSet,
     St::Cid: labeler_view_state::IsSet,
 {
@@ -863,85 +863,85 @@ pub mod labeler_view_detailed_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Policies;
+        type Uri;
+        type Cid;
         type Creator;
         type IndexedAt;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Policies = Unset;
+        type Uri = Unset;
+        type Cid = Unset;
         type Creator = Unset;
         type IndexedAt = Unset;
-        type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Policies = St::Policies;
-        type Creator = St::Creator;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `policies` field to Set
     pub struct SetPolicies<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPolicies<St> {}
     impl<St: State> State for SetPolicies<St> {
-        type Cid = St::Cid;
         type Policies = Set<members::policies>;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Creator = St::Creator;
+        type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Policies = St::Policies;
+        type Uri = Set<members::uri>;
+        type Cid = St::Cid;
         type Creator = St::Creator;
         type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Policies = St::Policies;
         type Uri = St::Uri;
+        type Cid = Set<members::cid>;
+        type Creator = St::Creator;
+        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `creator` field to Set
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
-        type Cid = St::Cid;
         type Policies = St::Policies;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
         type Creator = Set<members::creator>;
         type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Cid = St::Cid;
         type Policies = St::Policies;
-        type Creator = St::Creator;
-        type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
-        type Policies = St::Policies;
         type Creator = St::Creator;
-        type IndexedAt = St::IndexedAt;
-        type Uri = Set<members::uri>;
+        type IndexedAt = Set<members::indexed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `policies` field
         pub struct policies(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `creator` field
         pub struct creator(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -1191,11 +1191,11 @@ impl<
 impl<S: BosStr, St> LabelerViewDetailedBuilder<S, St>
 where
     St: labeler_view_detailed_state::State,
-    St::Cid: labeler_view_detailed_state::IsSet,
     St::Policies: labeler_view_detailed_state::IsSet,
+    St::Uri: labeler_view_detailed_state::IsSet,
+    St::Cid: labeler_view_detailed_state::IsSet,
     St::Creator: labeler_view_detailed_state::IsSet,
     St::IndexedAt: labeler_view_detailed_state::IsSet,
-    St::Uri: labeler_view_detailed_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LabelerViewDetailed<S> {
diff --git a/crates/jacquard-api/src/app_bsky/labeler/service.rs b/crates/jacquard-api/src/app_bsky/labeler/service.rs
index 3f5e94cc..933966eb 100644
--- a/crates/jacquard-api/src/app_bsky/labeler/service.rs
+++ b/crates/jacquard-api/src/app_bsky/labeler/service.rs
@@ -127,37 +127,37 @@ pub mod service_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Policies;
         type CreatedAt;
+        type Policies;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Policies = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `policies` field to Set
-    pub struct SetPolicies<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPolicies<St> {}
-    impl<St: State> State for SetPolicies<St> {
-        type Policies = Set<members::policies>;
-        type CreatedAt = St::CreatedAt;
+        type Policies = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Policies = St::Policies;
         type CreatedAt = Set<members::created_at>;
+        type Policies = St::Policies;
+    }
+    ///State transition - sets the `policies` field to Set
+    pub struct SetPolicies<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPolicies<St> {}
+    impl<St: State> State for SetPolicies<St> {
+        type CreatedAt = St::CreatedAt;
+        type Policies = Set<members::policies>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `policies` field
-        pub struct policies(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `policies` field
+        pub struct policies(());
     }
 }
 
@@ -292,8 +292,8 @@ impl<S: BosStr, St: service_state::State> ServiceBuilder<S, St> {
 impl<S: BosStr, St> ServiceBuilder<S, St>
 where
     St: service_state::State,
-    St::Policies: service_state::IsSet,
     St::CreatedAt: service_state::IsSet,
+    St::Policies: service_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Service<S> {
diff --git a/crates/jacquard-api/src/app_bsky/notification.rs b/crates/jacquard-api/src/app_bsky/notification.rs
index 0ece76a1..517e4be6 100644
--- a/crates/jacquard-api/src/app_bsky/notification.rs
+++ b/crates/jacquard-api/src/app_bsky/notification.rs
@@ -395,37 +395,37 @@ pub mod activity_subscription_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Reply;
         type Post;
+        type Reply;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Reply = Unset;
         type Post = Unset;
-    }
-    ///State transition - sets the `reply` field to Set
-    pub struct SetReply<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReply<St> {}
-    impl<St: State> State for SetReply<St> {
-        type Reply = Set<members::reply>;
-        type Post = St::Post;
+        type Reply = Unset;
     }
     ///State transition - sets the `post` field to Set
     pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPost<St> {}
     impl<St: State> State for SetPost<St> {
-        type Reply = St::Reply;
         type Post = Set<members::post>;
+        type Reply = St::Reply;
+    }
+    ///State transition - sets the `reply` field to Set
+    pub struct SetReply<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReply<St> {}
+    impl<St: State> State for SetReply<St> {
+        type Post = St::Post;
+        type Reply = Set<members::reply>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `reply` field
-        pub struct reply(());
         ///Marker type for the `post` field
         pub struct post(());
+        ///Marker type for the `reply` field
+        pub struct reply(());
     }
 }
 
@@ -498,8 +498,8 @@ where
 impl<S: BosStr, St> ActivitySubscriptionBuilder<S, St>
 where
     St: activity_subscription_state::State,
-    St::Reply: activity_subscription_state::IsSet,
     St::Post: activity_subscription_state::IsSet,
+    St::Reply: activity_subscription_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ActivitySubscription<S> {
@@ -954,49 +954,49 @@ pub mod filterable_preference_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type List;
         type Push;
+        type List;
         type Include;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type List = Unset;
         type Push = Unset;
+        type List = Unset;
         type Include = Unset;
     }
-    ///State transition - sets the `list` field to Set
-    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetList<St> {}
-    impl<St: State> State for SetList<St> {
-        type List = Set<members::list>;
-        type Push = St::Push;
-        type Include = St::Include;
-    }
     ///State transition - sets the `push` field to Set
     pub struct SetPush<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPush<St> {}
     impl<St: State> State for SetPush<St> {
-        type List = St::List;
         type Push = Set<members::push>;
+        type List = St::List;
+        type Include = St::Include;
+    }
+    ///State transition - sets the `list` field to Set
+    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetList<St> {}
+    impl<St: State> State for SetList<St> {
+        type Push = St::Push;
+        type List = Set<members::list>;
         type Include = St::Include;
     }
     ///State transition - sets the `include` field to Set
     pub struct SetInclude<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetInclude<St> {}
     impl<St: State> State for SetInclude<St> {
-        type List = St::List;
         type Push = St::Push;
+        type List = St::List;
         type Include = Set<members::include>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `list` field
-        pub struct list(());
         ///Marker type for the `push` field
         pub struct push(());
+        ///Marker type for the `list` field
+        pub struct list(());
         ///Marker type for the `include` field
         pub struct include(());
     }
@@ -1090,8 +1090,8 @@ where
 impl<S: BosStr, St> FilterablePreferenceBuilder<S, St>
 where
     St: filterable_preference_state::State,
-    St::List: filterable_preference_state::IsSet,
     St::Push: filterable_preference_state::IsSet,
+    St::List: filterable_preference_state::IsSet,
     St::Include: filterable_preference_state::IsSet,
 {
     /// Build the final struct.
@@ -1261,301 +1261,301 @@ pub mod preferences_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StarterpackJoined;
-        type Like;
         type Chat;
-        type Follow;
-        type Mention;
+        type Like;
+        type Quote;
+        type Reply;
+        type LikeViaRepost;
+        type SubscribedPost;
         type Repost;
+        type Follow;
+        type StarterpackJoined;
         type RepostViaRepost;
-        type SubscribedPost;
         type Unverified;
-        type Quote;
-        type LikeViaRepost;
+        type Mention;
         type Verified;
-        type Reply;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StarterpackJoined = Unset;
-        type Like = Unset;
         type Chat = Unset;
-        type Follow = Unset;
-        type Mention = Unset;
+        type Like = Unset;
+        type Quote = Unset;
+        type Reply = Unset;
+        type LikeViaRepost = Unset;
+        type SubscribedPost = Unset;
         type Repost = Unset;
+        type Follow = Unset;
+        type StarterpackJoined = Unset;
         type RepostViaRepost = Unset;
-        type SubscribedPost = Unset;
         type Unverified = Unset;
-        type Quote = Unset;
-        type LikeViaRepost = Unset;
+        type Mention = Unset;
         type Verified = Unset;
-        type Reply = Unset;
     }
-    ///State transition - sets the `starterpack_joined` field to Set
-    pub struct SetStarterpackJoined<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStarterpackJoined<St> {}
-    impl<St: State> State for SetStarterpackJoined<St> {
-        type StarterpackJoined = Set<members::starterpack_joined>;
+    ///State transition - sets the `chat` field to Set
+    pub struct SetChat<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChat<St> {}
+    impl<St: State> State for SetChat<St> {
+        type Chat = Set<members::chat>;
         type Like = St::Like;
-        type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type Quote = St::Quote;
+        type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
     ///State transition - sets the `like` field to Set
     pub struct SetLike<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLike<St> {}
     impl<St: State> State for SetLike<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = Set<members::like>;
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type Like = Set<members::like>;
+        type Quote = St::Quote;
+        type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
-    ///State transition - sets the `chat` field to Set
-    pub struct SetChat<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChat<St> {}
-    impl<St: State> State for SetChat<St> {
-        type StarterpackJoined = St::StarterpackJoined;
+    ///State transition - sets the `quote` field to Set
+    pub struct SetQuote<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuote<St> {}
+    impl<St: State> State for SetQuote<St> {
+        type Chat = St::Chat;
         type Like = St::Like;
-        type Chat = Set<members::chat>;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type Quote = Set<members::quote>;
+        type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
-    ///State transition - sets the `follow` field to Set
-    pub struct SetFollow<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFollow<St> {}
-    impl<St: State> State for SetFollow<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
+    ///State transition - sets the `reply` field to Set
+    pub struct SetReply<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReply<St> {}
+    impl<St: State> State for SetReply<St> {
         type Chat = St::Chat;
-        type Follow = Set<members::follow>;
-        type Mention = St::Mention;
+        type Like = St::Like;
+        type Quote = St::Quote;
+        type Reply = Set<members::reply>;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
-    ///State transition - sets the `mention` field to Set
-    pub struct SetMention<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMention<St> {}
-    impl<St: State> State for SetMention<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
+    ///State transition - sets the `like_via_repost` field to Set
+    pub struct SetLikeViaRepost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLikeViaRepost<St> {}
+    impl<St: State> State for SetLikeViaRepost<St> {
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = Set<members::mention>;
+        type Like = St::Like;
+        type Quote = St::Quote;
+        type Reply = St::Reply;
+        type LikeViaRepost = Set<members::like_via_repost>;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
+        type Mention = St::Mention;
+        type Verified = St::Verified;
+    }
+    ///State transition - sets the `subscribed_post` field to Set
+    pub struct SetSubscribedPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubscribedPost<St> {}
+    impl<St: State> State for SetSubscribedPost<St> {
+        type Chat = St::Chat;
+        type Like = St::Like;
         type Quote = St::Quote;
+        type Reply = St::Reply;
         type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = Set<members::subscribed_post>;
+        type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
+        type RepostViaRepost = St::RepostViaRepost;
+        type Unverified = St::Unverified;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
     ///State transition - sets the `repost` field to Set
     pub struct SetRepost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepost<St> {}
     impl<St: State> State for SetRepost<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type Like = St::Like;
+        type Quote = St::Quote;
+        type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = Set<members::repost>;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
+        type Mention = St::Mention;
+        type Verified = St::Verified;
+    }
+    ///State transition - sets the `follow` field to Set
+    pub struct SetFollow<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFollow<St> {}
+    impl<St: State> State for SetFollow<St> {
+        type Chat = St::Chat;
+        type Like = St::Like;
         type Quote = St::Quote;
+        type Reply = St::Reply;
         type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
+        type Repost = St::Repost;
+        type Follow = Set<members::follow>;
+        type StarterpackJoined = St::StarterpackJoined;
+        type RepostViaRepost = St::RepostViaRepost;
+        type Unverified = St::Unverified;
+        type Mention = St::Mention;
         type Verified = St::Verified;
+    }
+    ///State transition - sets the `starterpack_joined` field to Set
+    pub struct SetStarterpackJoined<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStarterpackJoined<St> {}
+    impl<St: State> State for SetStarterpackJoined<St> {
+        type Chat = St::Chat;
+        type Like = St::Like;
+        type Quote = St::Quote;
         type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
+        type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = Set<members::starterpack_joined>;
+        type RepostViaRepost = St::RepostViaRepost;
+        type Unverified = St::Unverified;
+        type Mention = St::Mention;
+        type Verified = St::Verified;
     }
     ///State transition - sets the `repost_via_repost` field to Set
     pub struct SetRepostViaRepost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepostViaRepost<St> {}
     impl<St: State> State for SetRepostViaRepost<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
-        type Repost = St::Repost;
-        type RepostViaRepost = Set<members::repost_via_repost>;
-        type SubscribedPost = St::SubscribedPost;
-        type Unverified = St::Unverified;
+        type Like = St::Like;
         type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
-        type Verified = St::Verified;
         type Reply = St::Reply;
-    }
-    ///State transition - sets the `subscribed_post` field to Set
-    pub struct SetSubscribedPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubscribedPost<St> {}
-    impl<St: State> State for SetSubscribedPost<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
-        type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
-        type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = Set<members::subscribed_post>;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
+        type RepostViaRepost = Set<members::repost_via_repost>;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
     ///State transition - sets the `unverified` field to Set
     pub struct SetUnverified<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUnverified<St> {}
     impl<St: State> State for SetUnverified<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
-        type Repost = St::Repost;
-        type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
-        type Unverified = Set<members::unverified>;
+        type Like = St::Like;
         type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
-        type Verified = St::Verified;
         type Reply = St::Reply;
-    }
-    ///State transition - sets the `quote` field to Set
-    pub struct SetQuote<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuote<St> {}
-    impl<St: State> State for SetQuote<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
-        type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
-        type Unverified = St::Unverified;
-        type Quote = Set<members::quote>;
-        type LikeViaRepost = St::LikeViaRepost;
+        type Unverified = Set<members::unverified>;
+        type Mention = St::Mention;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
-    ///State transition - sets the `like_via_repost` field to Set
-    pub struct SetLikeViaRepost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLikeViaRepost<St> {}
-    impl<St: State> State for SetLikeViaRepost<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
+    ///State transition - sets the `mention` field to Set
+    pub struct SetMention<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMention<St> {}
+    impl<St: State> State for SetMention<St> {
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type Like = St::Like;
+        type Quote = St::Quote;
+        type Reply = St::Reply;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = Set<members::like_via_repost>;
+        type Mention = Set<members::mention>;
         type Verified = St::Verified;
-        type Reply = St::Reply;
     }
     ///State transition - sets the `verified` field to Set
     pub struct SetVerified<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVerified<St> {}
     impl<St: State> State for SetVerified<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
         type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
-        type Repost = St::Repost;
-        type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
-        type Unverified = St::Unverified;
+        type Like = St::Like;
         type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
-        type Verified = Set<members::verified>;
         type Reply = St::Reply;
-    }
-    ///State transition - sets the `reply` field to Set
-    pub struct SetReply<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReply<St> {}
-    impl<St: State> State for SetReply<St> {
-        type StarterpackJoined = St::StarterpackJoined;
-        type Like = St::Like;
-        type Chat = St::Chat;
-        type Follow = St::Follow;
-        type Mention = St::Mention;
+        type LikeViaRepost = St::LikeViaRepost;
+        type SubscribedPost = St::SubscribedPost;
         type Repost = St::Repost;
+        type Follow = St::Follow;
+        type StarterpackJoined = St::StarterpackJoined;
         type RepostViaRepost = St::RepostViaRepost;
-        type SubscribedPost = St::SubscribedPost;
         type Unverified = St::Unverified;
-        type Quote = St::Quote;
-        type LikeViaRepost = St::LikeViaRepost;
-        type Verified = St::Verified;
-        type Reply = Set<members::reply>;
+        type Mention = St::Mention;
+        type Verified = Set<members::verified>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `starterpack_joined` field
-        pub struct starterpack_joined(());
-        ///Marker type for the `like` field
-        pub struct like(());
         ///Marker type for the `chat` field
         pub struct chat(());
-        ///Marker type for the `follow` field
-        pub struct follow(());
-        ///Marker type for the `mention` field
-        pub struct mention(());
+        ///Marker type for the `like` field
+        pub struct like(());
+        ///Marker type for the `quote` field
+        pub struct quote(());
+        ///Marker type for the `reply` field
+        pub struct reply(());
+        ///Marker type for the `like_via_repost` field
+        pub struct like_via_repost(());
+        ///Marker type for the `subscribed_post` field
+        pub struct subscribed_post(());
         ///Marker type for the `repost` field
         pub struct repost(());
+        ///Marker type for the `follow` field
+        pub struct follow(());
+        ///Marker type for the `starterpack_joined` field
+        pub struct starterpack_joined(());
         ///Marker type for the `repost_via_repost` field
         pub struct repost_via_repost(());
-        ///Marker type for the `subscribed_post` field
-        pub struct subscribed_post(());
         ///Marker type for the `unverified` field
         pub struct unverified(());
-        ///Marker type for the `quote` field
-        pub struct quote(());
-        ///Marker type for the `like_via_repost` field
-        pub struct like_via_repost(());
+        ///Marker type for the `mention` field
+        pub struct mention(());
         ///Marker type for the `verified` field
         pub struct verified(());
-        ///Marker type for the `reply` field
-        pub struct reply(());
     }
 }
 
@@ -1862,19 +1862,19 @@ where
 impl<S: BosStr, St> PreferencesBuilder<S, St>
 where
     St: preferences_state::State,
-    St::StarterpackJoined: preferences_state::IsSet,
-    St::Like: preferences_state::IsSet,
     St::Chat: preferences_state::IsSet,
-    St::Follow: preferences_state::IsSet,
-    St::Mention: preferences_state::IsSet,
+    St::Like: preferences_state::IsSet,
+    St::Quote: preferences_state::IsSet,
+    St::Reply: preferences_state::IsSet,
+    St::LikeViaRepost: preferences_state::IsSet,
+    St::SubscribedPost: preferences_state::IsSet,
     St::Repost: preferences_state::IsSet,
+    St::Follow: preferences_state::IsSet,
+    St::StarterpackJoined: preferences_state::IsSet,
     St::RepostViaRepost: preferences_state::IsSet,
-    St::SubscribedPost: preferences_state::IsSet,
     St::Unverified: preferences_state::IsSet,
-    St::Quote: preferences_state::IsSet,
-    St::LikeViaRepost: preferences_state::IsSet,
+    St::Mention: preferences_state::IsSet,
     St::Verified: preferences_state::IsSet,
-    St::Reply: preferences_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Preferences<S> {
@@ -1929,37 +1929,37 @@ pub mod subject_activity_subscription_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type ActivitySubscription;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type ActivitySubscription = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type ActivitySubscription = St::ActivitySubscription;
+        type Subject = Unset;
     }
     ///State transition - sets the `activity_subscription` field to Set
     pub struct SetActivitySubscription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActivitySubscription<St> {}
     impl<St: State> State for SetActivitySubscription<St> {
-        type Subject = St::Subject;
         type ActivitySubscription = Set<members::activity_subscription>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type ActivitySubscription = St::ActivitySubscription;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `activity_subscription` field
         pub struct activity_subscription(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -2043,8 +2043,8 @@ where
 impl<S: BosStr, St> SubjectActivitySubscriptionBuilder<S, St>
 where
     St: subject_activity_subscription_state::State,
-    St::Subject: subject_activity_subscription_state::IsSet,
     St::ActivitySubscription: subject_activity_subscription_state::IsSet,
+    St::Subject: subject_activity_subscription_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubjectActivitySubscription<S> {
diff --git a/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs b/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs
index 985a3005..d967835d 100644
--- a/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs
+++ b/crates/jacquard-api/src/app_bsky/notification/list_notifications.rs
@@ -383,127 +383,127 @@ pub mod notification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Author;
         type Cid;
-        type IndexedAt;
-        type Uri;
         type Reason;
         type Record;
+        type Uri;
+        type IndexedAt;
         type IsRead;
-        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Author = Unset;
         type Cid = Unset;
-        type IndexedAt = Unset;
-        type Uri = Unset;
         type Reason = Unset;
         type Record = Unset;
+        type Uri = Unset;
+        type IndexedAt = Unset;
         type IsRead = Unset;
-        type Author = Unset;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type Author = Set<members::author>;
+        type Cid = St::Cid;
+        type Reason = St::Reason;
+        type Record = St::Record;
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
+        type IsRead = St::IsRead;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Author = St::Author;
         type Cid = Set<members::cid>;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
         type Reason = St::Reason;
         type Record = St::Record;
-        type IsRead = St::IsRead;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Cid = St::Cid;
-        type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
-        type Reason = St::Reason;
-        type Record = St::Record;
-        type IsRead = St::IsRead;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Uri = Set<members::uri>;
-        type Reason = St::Reason;
-        type Record = St::Record;
         type IsRead = St::IsRead;
-        type Author = St::Author;
     }
     ///State transition - sets the `reason` field to Set
     pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReason<St> {}
     impl<St: State> State for SetReason<St> {
+        type Author = St::Author;
         type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
         type Reason = Set<members::reason>;
         type Record = St::Record;
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type IsRead = St::IsRead;
-        type Author = St::Author;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
+        type Author = St::Author;
         type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
         type Reason = St::Reason;
         type Record = Set<members::record>;
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type IsRead = St::IsRead;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Author = St::Author;
+        type Cid = St::Cid;
+        type Reason = St::Reason;
+        type Record = St::Record;
+        type Uri = Set<members::uri>;
+        type IndexedAt = St::IndexedAt;
+        type IsRead = St::IsRead;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
         type Author = St::Author;
+        type Cid = St::Cid;
+        type Reason = St::Reason;
+        type Record = St::Record;
+        type Uri = St::Uri;
+        type IndexedAt = Set<members::indexed_at>;
+        type IsRead = St::IsRead;
     }
     ///State transition - sets the `is_read` field to Set
     pub struct SetIsRead<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIsRead<St> {}
     impl<St: State> State for SetIsRead<St> {
-        type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
-        type Reason = St::Reason;
-        type Record = St::Record;
-        type IsRead = Set<members::is_read>;
         type Author = St::Author;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
         type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
         type Reason = St::Reason;
         type Record = St::Record;
-        type IsRead = St::IsRead;
-        type Author = Set<members::author>;
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
+        type IsRead = Set<members::is_read>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `author` field
+        pub struct author(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `reason` field
         pub struct reason(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `is_read` field
         pub struct is_read(());
-        ///Marker type for the `author` field
-        pub struct author(());
     }
 }
 
@@ -704,13 +704,13 @@ where
 impl<S: BosStr, St> NotificationBuilder<S, St>
 where
     St: notification_state::State,
+    St::Author: notification_state::IsSet,
     St::Cid: notification_state::IsSet,
-    St::IndexedAt: notification_state::IsSet,
-    St::Uri: notification_state::IsSet,
     St::Reason: notification_state::IsSet,
     St::Record: notification_state::IsSet,
+    St::Uri: notification_state::IsSet,
+    St::IndexedAt: notification_state::IsSet,
     St::IsRead: notification_state::IsSet,
-    St::Author: notification_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Notification<S> {
diff --git a/crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs b/crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs
index 172ee7a9..c1fe5490 100644
--- a/crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs
+++ b/crates/jacquard-api/src/app_bsky/notification/put_activity_subscription.rs
@@ -76,37 +76,37 @@ pub mod put_activity_subscription_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ActivitySubscription;
         type Subject;
+        type ActivitySubscription;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ActivitySubscription = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `activity_subscription` field to Set
-    pub struct SetActivitySubscription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActivitySubscription<St> {}
-    impl<St: State> State for SetActivitySubscription<St> {
-        type ActivitySubscription = Set<members::activity_subscription>;
-        type Subject = St::Subject;
+        type ActivitySubscription = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type ActivitySubscription = St::ActivitySubscription;
         type Subject = Set<members::subject>;
+        type ActivitySubscription = St::ActivitySubscription;
+    }
+    ///State transition - sets the `activity_subscription` field to Set
+    pub struct SetActivitySubscription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActivitySubscription<St> {}
+    impl<St: State> State for SetActivitySubscription<St> {
+        type Subject = St::Subject;
+        type ActivitySubscription = Set<members::activity_subscription>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `activity_subscription` field
-        pub struct activity_subscription(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `activity_subscription` field
+        pub struct activity_subscription(());
     }
 }
 
@@ -190,8 +190,8 @@ where
 impl<S: BosStr, St> PutActivitySubscriptionBuilder<S, St>
 where
     St: put_activity_subscription_state::State,
-    St::ActivitySubscription: put_activity_subscription_state::IsSet,
     St::Subject: put_activity_subscription_state::IsSet,
+    St::ActivitySubscription: put_activity_subscription_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PutActivitySubscription<S> {
diff --git a/crates/jacquard-api/src/app_bsky/notification/register_push.rs b/crates/jacquard-api/src/app_bsky/notification/register_push.rs
index 7e74e64f..d0a60d7b 100644
--- a/crates/jacquard-api/src/app_bsky/notification/register_push.rs
+++ b/crates/jacquard-api/src/app_bsky/notification/register_push.rs
@@ -155,8 +155,8 @@ pub mod register_push_state {
     pub trait State: sealed::Sealed {
         type Platform;
         type Token;
-        type ServiceDid;
         type AppId;
+        type ServiceDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -164,8 +164,8 @@ pub mod register_push_state {
     impl State for Empty {
         type Platform = Unset;
         type Token = Unset;
-        type ServiceDid = Unset;
         type AppId = Unset;
+        type ServiceDid = Unset;
     }
     ///State transition - sets the `platform` field to Set
     pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
@@ -173,8 +173,8 @@ pub mod register_push_state {
     impl<St: State> State for SetPlatform<St> {
         type Platform = Set<members::platform>;
         type Token = St::Token;
-        type ServiceDid = St::ServiceDid;
         type AppId = St::AppId;
+        type ServiceDid = St::ServiceDid;
     }
     ///State transition - sets the `token` field to Set
     pub struct SetToken<St: State = Empty>(PhantomData<fn() -> St>);
@@ -182,17 +182,8 @@ pub mod register_push_state {
     impl<St: State> State for SetToken<St> {
         type Platform = St::Platform;
         type Token = Set<members::token>;
-        type ServiceDid = St::ServiceDid;
-        type AppId = St::AppId;
-    }
-    ///State transition - sets the `service_did` field to Set
-    pub struct SetServiceDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetServiceDid<St> {}
-    impl<St: State> State for SetServiceDid<St> {
-        type Platform = St::Platform;
-        type Token = St::Token;
-        type ServiceDid = Set<members::service_did>;
         type AppId = St::AppId;
+        type ServiceDid = St::ServiceDid;
     }
     ///State transition - sets the `app_id` field to Set
     pub struct SetAppId<St: State = Empty>(PhantomData<fn() -> St>);
@@ -200,8 +191,17 @@ pub mod register_push_state {
     impl<St: State> State for SetAppId<St> {
         type Platform = St::Platform;
         type Token = St::Token;
-        type ServiceDid = St::ServiceDid;
         type AppId = Set<members::app_id>;
+        type ServiceDid = St::ServiceDid;
+    }
+    ///State transition - sets the `service_did` field to Set
+    pub struct SetServiceDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetServiceDid<St> {}
+    impl<St: State> State for SetServiceDid<St> {
+        type Platform = St::Platform;
+        type Token = St::Token;
+        type AppId = St::AppId;
+        type ServiceDid = Set<members::service_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -210,10 +210,10 @@ pub mod register_push_state {
         pub struct platform(());
         ///Marker type for the `token` field
         pub struct token(());
-        ///Marker type for the `service_did` field
-        pub struct service_did(());
         ///Marker type for the `app_id` field
         pub struct app_id(());
+        ///Marker type for the `service_did` field
+        pub struct service_did(());
     }
 }
 
@@ -342,8 +342,8 @@ where
     St: register_push_state::State,
     St::Platform: register_push_state::IsSet,
     St::Token: register_push_state::IsSet,
-    St::ServiceDid: register_push_state::IsSet,
     St::AppId: register_push_state::IsSet,
+    St::ServiceDid: register_push_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RegisterPush<S> {
diff --git a/crates/jacquard-api/src/app_bsky/notification/unregister_push.rs b/crates/jacquard-api/src/app_bsky/notification/unregister_push.rs
index c7e18f9b..be485406 100644
--- a/crates/jacquard-api/src/app_bsky/notification/unregister_push.rs
+++ b/crates/jacquard-api/src/app_bsky/notification/unregister_push.rs
@@ -150,67 +150,67 @@ pub mod unregister_push_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Token;
         type Platform;
         type AppId;
         type ServiceDid;
-        type Token;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Token = Unset;
         type Platform = Unset;
         type AppId = Unset;
         type ServiceDid = Unset;
-        type Token = Unset;
+    }
+    ///State transition - sets the `token` field to Set
+    pub struct SetToken<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetToken<St> {}
+    impl<St: State> State for SetToken<St> {
+        type Token = Set<members::token>;
+        type Platform = St::Platform;
+        type AppId = St::AppId;
+        type ServiceDid = St::ServiceDid;
     }
     ///State transition - sets the `platform` field to Set
     pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlatform<St> {}
     impl<St: State> State for SetPlatform<St> {
+        type Token = St::Token;
         type Platform = Set<members::platform>;
         type AppId = St::AppId;
         type ServiceDid = St::ServiceDid;
-        type Token = St::Token;
     }
     ///State transition - sets the `app_id` field to Set
     pub struct SetAppId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAppId<St> {}
     impl<St: State> State for SetAppId<St> {
+        type Token = St::Token;
         type Platform = St::Platform;
         type AppId = Set<members::app_id>;
         type ServiceDid = St::ServiceDid;
-        type Token = St::Token;
     }
     ///State transition - sets the `service_did` field to Set
     pub struct SetServiceDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetServiceDid<St> {}
     impl<St: State> State for SetServiceDid<St> {
-        type Platform = St::Platform;
-        type AppId = St::AppId;
-        type ServiceDid = Set<members::service_did>;
         type Token = St::Token;
-    }
-    ///State transition - sets the `token` field to Set
-    pub struct SetToken<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetToken<St> {}
-    impl<St: State> State for SetToken<St> {
         type Platform = St::Platform;
         type AppId = St::AppId;
-        type ServiceDid = St::ServiceDid;
-        type Token = Set<members::token>;
+        type ServiceDid = Set<members::service_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `token` field
+        pub struct token(());
         ///Marker type for the `platform` field
         pub struct platform(());
         ///Marker type for the `app_id` field
         pub struct app_id(());
         ///Marker type for the `service_did` field
         pub struct service_did(());
-        ///Marker type for the `token` field
-        pub struct token(());
     }
 }
 
@@ -318,10 +318,10 @@ where
 impl<S: BosStr, St> UnregisterPushBuilder<S, St>
 where
     St: unregister_push_state::State,
+    St::Token: unregister_push_state::IsSet,
     St::Platform: unregister_push_state::IsSet,
     St::AppId: unregister_push_state::IsSet,
     St::ServiceDid: unregister_push_state::IsSet,
-    St::Token: unregister_push_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UnregisterPush<S> {
diff --git a/crates/jacquard-api/src/app_bsky/richtext/facet.rs b/crates/jacquard-api/src/app_bsky/richtext/facet.rs
index b1f6a134..1aa96f2b 100644
--- a/crates/jacquard-api/src/app_bsky/richtext/facet.rs
+++ b/crates/jacquard-api/src/app_bsky/richtext/facet.rs
@@ -219,37 +219,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteStart;
         type ByteEnd;
+        type ByteStart;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteStart = Unset;
         type ByteEnd = Unset;
-    }
-    ///State transition - sets the `byte_start` field to Set
-    pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteStart<St> {}
-    impl<St: State> State for SetByteStart<St> {
-        type ByteStart = Set<members::byte_start>;
-        type ByteEnd = St::ByteEnd;
+        type ByteStart = Unset;
     }
     ///State transition - sets the `byte_end` field to Set
     pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteEnd<St> {}
     impl<St: State> State for SetByteEnd<St> {
-        type ByteStart = St::ByteStart;
         type ByteEnd = Set<members::byte_end>;
+        type ByteStart = St::ByteStart;
+    }
+    ///State transition - sets the `byte_start` field to Set
+    pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteStart<St> {}
+    impl<St: State> State for SetByteStart<St> {
+        type ByteEnd = St::ByteEnd;
+        type ByteStart = Set<members::byte_start>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_start` field
-        pub struct byte_start(());
         ///Marker type for the `byte_end` field
         pub struct byte_end(());
+        ///Marker type for the `byte_start` field
+        pub struct byte_start(());
     }
 }
 
@@ -319,8 +319,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteStart: byte_slice_state::IsSet,
     St::ByteEnd: byte_slice_state::IsSet,
+    St::ByteStart: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
diff --git a/crates/jacquard-api/src/app_bsky/unspecced.rs b/crates/jacquard-api/src/app_bsky/unspecced.rs
index 4d1eef35..d3fc94ec 100644
--- a/crates/jacquard-api/src/app_bsky/unspecced.rs
+++ b/crates/jacquard-api/src/app_bsky/unspecced.rs
@@ -731,50 +731,50 @@ pub mod age_assurance_event_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Status;
-        type AttemptId;
         type CreatedAt;
+        type AttemptId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Status = Unset;
-        type AttemptId = Unset;
         type CreatedAt = Unset;
+        type AttemptId = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
         type Status = Set<members::status>;
-        type AttemptId = St::AttemptId;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `attempt_id` field to Set
-    pub struct SetAttemptId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAttemptId<St> {}
-    impl<St: State> State for SetAttemptId<St> {
-        type Status = St::Status;
-        type AttemptId = Set<members::attempt_id>;
         type CreatedAt = St::CreatedAt;
+        type AttemptId = St::AttemptId;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Status = St::Status;
-        type AttemptId = St::AttemptId;
         type CreatedAt = Set<members::created_at>;
+        type AttemptId = St::AttemptId;
+    }
+    ///State transition - sets the `attempt_id` field to Set
+    pub struct SetAttemptId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAttemptId<St> {}
+    impl<St: State> State for SetAttemptId<St> {
+        type Status = St::Status;
+        type CreatedAt = St::CreatedAt;
+        type AttemptId = Set<members::attempt_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `status` field
         pub struct status(());
-        ///Marker type for the `attempt_id` field
-        pub struct attempt_id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `attempt_id` field
+        pub struct attempt_id(());
     }
 }
 
@@ -938,8 +938,8 @@ impl<S: BosStr, St> AgeAssuranceEventBuilder<S, St>
 where
     St: age_assurance_event_state::State,
     St::Status: age_assurance_event_state::IsSet,
-    St::AttemptId: age_assurance_event_state::IsSet,
     St::CreatedAt: age_assurance_event_state::IsSet,
+    St::AttemptId: age_assurance_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AgeAssuranceEvent<S> {
@@ -1781,105 +1781,105 @@ pub mod skeleton_trend_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Link;
-        type Topic;
-        type PostCount;
         type Dids;
         type StartedAt;
         type DisplayName;
+        type Link;
+        type PostCount;
+        type Topic;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Link = Unset;
-        type Topic = Unset;
-        type PostCount = Unset;
         type Dids = Unset;
         type StartedAt = Unset;
         type DisplayName = Unset;
-    }
-    ///State transition - sets the `link` field to Set
-    pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLink<St> {}
-    impl<St: State> State for SetLink<St> {
-        type Link = Set<members::link>;
-        type Topic = St::Topic;
-        type PostCount = St::PostCount;
-        type Dids = St::Dids;
-        type StartedAt = St::StartedAt;
-        type DisplayName = St::DisplayName;
-    }
-    ///State transition - sets the `topic` field to Set
-    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTopic<St> {}
-    impl<St: State> State for SetTopic<St> {
-        type Link = St::Link;
-        type Topic = Set<members::topic>;
-        type PostCount = St::PostCount;
-        type Dids = St::Dids;
-        type StartedAt = St::StartedAt;
-        type DisplayName = St::DisplayName;
-    }
-    ///State transition - sets the `post_count` field to Set
-    pub struct SetPostCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPostCount<St> {}
-    impl<St: State> State for SetPostCount<St> {
-        type Link = St::Link;
-        type Topic = St::Topic;
-        type PostCount = Set<members::post_count>;
-        type Dids = St::Dids;
-        type StartedAt = St::StartedAt;
-        type DisplayName = St::DisplayName;
+        type Link = Unset;
+        type PostCount = Unset;
+        type Topic = Unset;
     }
     ///State transition - sets the `dids` field to Set
     pub struct SetDids<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDids<St> {}
     impl<St: State> State for SetDids<St> {
-        type Link = St::Link;
-        type Topic = St::Topic;
-        type PostCount = St::PostCount;
         type Dids = Set<members::dids>;
         type StartedAt = St::StartedAt;
         type DisplayName = St::DisplayName;
+        type Link = St::Link;
+        type PostCount = St::PostCount;
+        type Topic = St::Topic;
     }
     ///State transition - sets the `started_at` field to Set
     pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStartedAt<St> {}
     impl<St: State> State for SetStartedAt<St> {
-        type Link = St::Link;
-        type Topic = St::Topic;
-        type PostCount = St::PostCount;
         type Dids = St::Dids;
         type StartedAt = Set<members::started_at>;
         type DisplayName = St::DisplayName;
+        type Link = St::Link;
+        type PostCount = St::PostCount;
+        type Topic = St::Topic;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
+        type Dids = St::Dids;
+        type StartedAt = St::StartedAt;
+        type DisplayName = Set<members::display_name>;
         type Link = St::Link;
+        type PostCount = St::PostCount;
         type Topic = St::Topic;
+    }
+    ///State transition - sets the `link` field to Set
+    pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLink<St> {}
+    impl<St: State> State for SetLink<St> {
+        type Dids = St::Dids;
+        type StartedAt = St::StartedAt;
+        type DisplayName = St::DisplayName;
+        type Link = Set<members::link>;
         type PostCount = St::PostCount;
+        type Topic = St::Topic;
+    }
+    ///State transition - sets the `post_count` field to Set
+    pub struct SetPostCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPostCount<St> {}
+    impl<St: State> State for SetPostCount<St> {
         type Dids = St::Dids;
         type StartedAt = St::StartedAt;
-        type DisplayName = Set<members::display_name>;
+        type DisplayName = St::DisplayName;
+        type Link = St::Link;
+        type PostCount = Set<members::post_count>;
+        type Topic = St::Topic;
+    }
+    ///State transition - sets the `topic` field to Set
+    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTopic<St> {}
+    impl<St: State> State for SetTopic<St> {
+        type Dids = St::Dids;
+        type StartedAt = St::StartedAt;
+        type DisplayName = St::DisplayName;
+        type Link = St::Link;
+        type PostCount = St::PostCount;
+        type Topic = Set<members::topic>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `link` field
-        pub struct link(());
-        ///Marker type for the `topic` field
-        pub struct topic(());
-        ///Marker type for the `post_count` field
-        pub struct post_count(());
         ///Marker type for the `dids` field
         pub struct dids(());
         ///Marker type for the `started_at` field
         pub struct started_at(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
+        ///Marker type for the `link` field
+        pub struct link(());
+        ///Marker type for the `post_count` field
+        pub struct post_count(());
+        ///Marker type for the `topic` field
+        pub struct topic(());
     }
 }
 
@@ -2060,12 +2060,12 @@ where
 impl<S: BosStr, St> SkeletonTrendBuilder<S, St>
 where
     St: skeleton_trend_state::State,
-    St::Link: skeleton_trend_state::IsSet,
-    St::Topic: skeleton_trend_state::IsSet,
-    St::PostCount: skeleton_trend_state::IsSet,
     St::Dids: skeleton_trend_state::IsSet,
     St::StartedAt: skeleton_trend_state::IsSet,
     St::DisplayName: skeleton_trend_state::IsSet,
+    St::Link: skeleton_trend_state::IsSet,
+    St::PostCount: skeleton_trend_state::IsSet,
+    St::Topic: skeleton_trend_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SkeletonTrend<S> {
@@ -2210,105 +2210,105 @@ pub mod thread_item_post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MoreParents;
-        type HiddenByThreadgate;
         type Post;
+        type HiddenByThreadgate;
         type OpThread;
-        type MoreReplies;
         type MutedByViewer;
+        type MoreReplies;
+        type MoreParents;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MoreParents = Unset;
-        type HiddenByThreadgate = Unset;
         type Post = Unset;
+        type HiddenByThreadgate = Unset;
         type OpThread = Unset;
-        type MoreReplies = Unset;
         type MutedByViewer = Unset;
+        type MoreReplies = Unset;
+        type MoreParents = Unset;
     }
-    ///State transition - sets the `more_parents` field to Set
-    pub struct SetMoreParents<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMoreParents<St> {}
-    impl<St: State> State for SetMoreParents<St> {
-        type MoreParents = Set<members::more_parents>;
+    ///State transition - sets the `post` field to Set
+    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPost<St> {}
+    impl<St: State> State for SetPost<St> {
+        type Post = Set<members::post>;
         type HiddenByThreadgate = St::HiddenByThreadgate;
-        type Post = St::Post;
         type OpThread = St::OpThread;
-        type MoreReplies = St::MoreReplies;
         type MutedByViewer = St::MutedByViewer;
+        type MoreReplies = St::MoreReplies;
+        type MoreParents = St::MoreParents;
     }
     ///State transition - sets the `hidden_by_threadgate` field to Set
     pub struct SetHiddenByThreadgate<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHiddenByThreadgate<St> {}
     impl<St: State> State for SetHiddenByThreadgate<St> {
-        type MoreParents = St::MoreParents;
-        type HiddenByThreadgate = Set<members::hidden_by_threadgate>;
         type Post = St::Post;
+        type HiddenByThreadgate = Set<members::hidden_by_threadgate>;
         type OpThread = St::OpThread;
-        type MoreReplies = St::MoreReplies;
         type MutedByViewer = St::MutedByViewer;
-    }
-    ///State transition - sets the `post` field to Set
-    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPost<St> {}
-    impl<St: State> State for SetPost<St> {
-        type MoreParents = St::MoreParents;
-        type HiddenByThreadgate = St::HiddenByThreadgate;
-        type Post = Set<members::post>;
-        type OpThread = St::OpThread;
         type MoreReplies = St::MoreReplies;
-        type MutedByViewer = St::MutedByViewer;
+        type MoreParents = St::MoreParents;
     }
     ///State transition - sets the `op_thread` field to Set
     pub struct SetOpThread<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOpThread<St> {}
     impl<St: State> State for SetOpThread<St> {
-        type MoreParents = St::MoreParents;
-        type HiddenByThreadgate = St::HiddenByThreadgate;
         type Post = St::Post;
+        type HiddenByThreadgate = St::HiddenByThreadgate;
         type OpThread = Set<members::op_thread>;
-        type MoreReplies = St::MoreReplies;
         type MutedByViewer = St::MutedByViewer;
+        type MoreReplies = St::MoreReplies;
+        type MoreParents = St::MoreParents;
+    }
+    ///State transition - sets the `muted_by_viewer` field to Set
+    pub struct SetMutedByViewer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMutedByViewer<St> {}
+    impl<St: State> State for SetMutedByViewer<St> {
+        type Post = St::Post;
+        type HiddenByThreadgate = St::HiddenByThreadgate;
+        type OpThread = St::OpThread;
+        type MutedByViewer = Set<members::muted_by_viewer>;
+        type MoreReplies = St::MoreReplies;
+        type MoreParents = St::MoreParents;
     }
     ///State transition - sets the `more_replies` field to Set
     pub struct SetMoreReplies<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMoreReplies<St> {}
     impl<St: State> State for SetMoreReplies<St> {
-        type MoreParents = St::MoreParents;
-        type HiddenByThreadgate = St::HiddenByThreadgate;
         type Post = St::Post;
+        type HiddenByThreadgate = St::HiddenByThreadgate;
         type OpThread = St::OpThread;
-        type MoreReplies = Set<members::more_replies>;
         type MutedByViewer = St::MutedByViewer;
-    }
-    ///State transition - sets the `muted_by_viewer` field to Set
-    pub struct SetMutedByViewer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMutedByViewer<St> {}
-    impl<St: State> State for SetMutedByViewer<St> {
+        type MoreReplies = Set<members::more_replies>;
         type MoreParents = St::MoreParents;
-        type HiddenByThreadgate = St::HiddenByThreadgate;
+    }
+    ///State transition - sets the `more_parents` field to Set
+    pub struct SetMoreParents<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMoreParents<St> {}
+    impl<St: State> State for SetMoreParents<St> {
         type Post = St::Post;
+        type HiddenByThreadgate = St::HiddenByThreadgate;
         type OpThread = St::OpThread;
+        type MutedByViewer = St::MutedByViewer;
         type MoreReplies = St::MoreReplies;
-        type MutedByViewer = Set<members::muted_by_viewer>;
+        type MoreParents = Set<members::more_parents>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `more_parents` field
-        pub struct more_parents(());
-        ///Marker type for the `hidden_by_threadgate` field
-        pub struct hidden_by_threadgate(());
         ///Marker type for the `post` field
         pub struct post(());
+        ///Marker type for the `hidden_by_threadgate` field
+        pub struct hidden_by_threadgate(());
         ///Marker type for the `op_thread` field
         pub struct op_thread(());
-        ///Marker type for the `more_replies` field
-        pub struct more_replies(());
         ///Marker type for the `muted_by_viewer` field
         pub struct muted_by_viewer(());
+        ///Marker type for the `more_replies` field
+        pub struct more_replies(());
+        ///Marker type for the `more_parents` field
+        pub struct more_parents(());
     }
 }
 
@@ -2461,12 +2461,12 @@ where
 impl<S: BosStr, St> ThreadItemPostBuilder<S, St>
 where
     St: thread_item_post_state::State,
-    St::MoreParents: thread_item_post_state::IsSet,
-    St::HiddenByThreadgate: thread_item_post_state::IsSet,
     St::Post: thread_item_post_state::IsSet,
+    St::HiddenByThreadgate: thread_item_post_state::IsSet,
     St::OpThread: thread_item_post_state::IsSet,
-    St::MoreReplies: thread_item_post_state::IsSet,
     St::MutedByViewer: thread_item_post_state::IsSet,
+    St::MoreReplies: thread_item_post_state::IsSet,
+    St::MoreParents: thread_item_post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ThreadItemPost<S> {
@@ -2507,105 +2507,105 @@ pub mod trend_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StartedAt;
+        type PostCount;
         type Actors;
-        type Link;
         type Topic;
+        type Link;
+        type StartedAt;
         type DisplayName;
-        type PostCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StartedAt = Unset;
+        type PostCount = Unset;
         type Actors = Unset;
-        type Link = Unset;
         type Topic = Unset;
+        type Link = Unset;
+        type StartedAt = Unset;
         type DisplayName = Unset;
-        type PostCount = Unset;
     }
-    ///State transition - sets the `started_at` field to Set
-    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
-    impl<St: State> State for SetStartedAt<St> {
-        type StartedAt = Set<members::started_at>;
+    ///State transition - sets the `post_count` field to Set
+    pub struct SetPostCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPostCount<St> {}
+    impl<St: State> State for SetPostCount<St> {
+        type PostCount = Set<members::post_count>;
         type Actors = St::Actors;
-        type Link = St::Link;
         type Topic = St::Topic;
+        type Link = St::Link;
+        type StartedAt = St::StartedAt;
         type DisplayName = St::DisplayName;
-        type PostCount = St::PostCount;
     }
     ///State transition - sets the `actors` field to Set
     pub struct SetActors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActors<St> {}
     impl<St: State> State for SetActors<St> {
-        type StartedAt = St::StartedAt;
+        type PostCount = St::PostCount;
         type Actors = Set<members::actors>;
-        type Link = St::Link;
         type Topic = St::Topic;
+        type Link = St::Link;
+        type StartedAt = St::StartedAt;
         type DisplayName = St::DisplayName;
+    }
+    ///State transition - sets the `topic` field to Set
+    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTopic<St> {}
+    impl<St: State> State for SetTopic<St> {
         type PostCount = St::PostCount;
+        type Actors = St::Actors;
+        type Topic = Set<members::topic>;
+        type Link = St::Link;
+        type StartedAt = St::StartedAt;
+        type DisplayName = St::DisplayName;
     }
     ///State transition - sets the `link` field to Set
     pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLink<St> {}
     impl<St: State> State for SetLink<St> {
-        type StartedAt = St::StartedAt;
+        type PostCount = St::PostCount;
         type Actors = St::Actors;
-        type Link = Set<members::link>;
         type Topic = St::Topic;
+        type Link = Set<members::link>;
+        type StartedAt = St::StartedAt;
         type DisplayName = St::DisplayName;
-        type PostCount = St::PostCount;
     }
-    ///State transition - sets the `topic` field to Set
-    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTopic<St> {}
-    impl<St: State> State for SetTopic<St> {
-        type StartedAt = St::StartedAt;
+    ///State transition - sets the `started_at` field to Set
+    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
+    impl<St: State> State for SetStartedAt<St> {
+        type PostCount = St::PostCount;
         type Actors = St::Actors;
+        type Topic = St::Topic;
         type Link = St::Link;
-        type Topic = Set<members::topic>;
+        type StartedAt = Set<members::started_at>;
         type DisplayName = St::DisplayName;
-        type PostCount = St::PostCount;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
-        type StartedAt = St::StartedAt;
-        type Actors = St::Actors;
-        type Link = St::Link;
-        type Topic = St::Topic;
-        type DisplayName = Set<members::display_name>;
         type PostCount = St::PostCount;
-    }
-    ///State transition - sets the `post_count` field to Set
-    pub struct SetPostCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPostCount<St> {}
-    impl<St: State> State for SetPostCount<St> {
-        type StartedAt = St::StartedAt;
         type Actors = St::Actors;
-        type Link = St::Link;
         type Topic = St::Topic;
-        type DisplayName = St::DisplayName;
-        type PostCount = Set<members::post_count>;
+        type Link = St::Link;
+        type StartedAt = St::StartedAt;
+        type DisplayName = Set<members::display_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `started_at` field
-        pub struct started_at(());
+        ///Marker type for the `post_count` field
+        pub struct post_count(());
         ///Marker type for the `actors` field
         pub struct actors(());
-        ///Marker type for the `link` field
-        pub struct link(());
         ///Marker type for the `topic` field
         pub struct topic(());
+        ///Marker type for the `link` field
+        pub struct link(());
+        ///Marker type for the `started_at` field
+        pub struct started_at(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
-        ///Marker type for the `post_count` field
-        pub struct post_count(());
     }
 }
 
@@ -2786,12 +2786,12 @@ where
 impl<S: BosStr, St> TrendViewBuilder<S, St>
 where
     St: trend_view_state::State,
-    St::StartedAt: trend_view_state::IsSet,
+    St::PostCount: trend_view_state::IsSet,
     St::Actors: trend_view_state::IsSet,
-    St::Link: trend_view_state::IsSet,
     St::Topic: trend_view_state::IsSet,
+    St::Link: trend_view_state::IsSet,
+    St::StartedAt: trend_view_state::IsSet,
     St::DisplayName: trend_view_state::IsSet,
-    St::PostCount: trend_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TrendView<S> {
diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs
index d9a02a2a..c5278940 100644
--- a/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs
+++ b/crates/jacquard-api/src/app_bsky/unspecced/get_config.rs
@@ -100,37 +100,37 @@ pub mod live_now_config_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Domains;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Domains = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Domains = St::Domains;
+        type Did = Unset;
     }
     ///State transition - sets the `domains` field to Set
     pub struct SetDomains<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDomains<St> {}
     impl<St: State> State for SetDomains<St> {
-        type Did = St::Did;
         type Domains = Set<members::domains>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Domains = St::Domains;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `domains` field
         pub struct domains(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -200,8 +200,8 @@ where
 impl<S: BosStr, St> LiveNowConfigBuilder<S, St>
 where
     St: live_now_config_state::State,
-    St::Did: live_now_config_state::IsSet,
     St::Domains: live_now_config_state::IsSet,
+    St::Did: live_now_config_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LiveNowConfig<S> {
diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs
index 2ab47c35..fc949390 100644
--- a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs
+++ b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_other_v2.rs
@@ -199,49 +199,49 @@ pub mod thread_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Depth;
+        type Uri;
         type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Depth = Unset;
+        type Uri = Unset;
         type Value = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Depth = St::Depth;
-        type Value = St::Value;
-    }
     ///State transition - sets the `depth` field to Set
     pub struct SetDepth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDepth<St> {}
     impl<St: State> State for SetDepth<St> {
-        type Uri = St::Uri;
         type Depth = Set<members::depth>;
+        type Uri = St::Uri;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Depth = St::Depth;
+        type Uri = Set<members::uri>;
         type Value = St::Value;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Uri = St::Uri;
         type Depth = St::Depth;
+        type Uri = St::Uri;
         type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `depth` field
         pub struct depth(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `value` field
         pub struct value(());
     }
@@ -332,8 +332,8 @@ where
 impl<S: BosStr, St> ThreadItemBuilder<S, St>
 where
     St: thread_item_state::State,
-    St::Uri: thread_item_state::IsSet,
     St::Depth: thread_item_state::IsSet,
+    St::Uri: thread_item_state::IsSet,
     St::Value: thread_item_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs
index 36aaadb1..611a7a06 100644
--- a/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs
+++ b/crates/jacquard-api/src/app_bsky/unspecced/get_post_thread_v2.rs
@@ -304,51 +304,51 @@ pub mod thread_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Depth;
         type Uri;
         type Value;
+        type Depth;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Depth = Unset;
         type Uri = Unset;
         type Value = Unset;
-    }
-    ///State transition - sets the `depth` field to Set
-    pub struct SetDepth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDepth<St> {}
-    impl<St: State> State for SetDepth<St> {
-        type Depth = Set<members::depth>;
-        type Uri = St::Uri;
-        type Value = St::Value;
+        type Depth = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Depth = St::Depth;
         type Uri = Set<members::uri>;
         type Value = St::Value;
+        type Depth = St::Depth;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Depth = St::Depth;
         type Uri = St::Uri;
         type Value = Set<members::value>;
+        type Depth = St::Depth;
+    }
+    ///State transition - sets the `depth` field to Set
+    pub struct SetDepth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDepth<St> {}
+    impl<St: State> State for SetDepth<St> {
+        type Uri = St::Uri;
+        type Value = St::Value;
+        type Depth = Set<members::depth>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `depth` field
-        pub struct depth(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `value` field
         pub struct value(());
+        ///Marker type for the `depth` field
+        pub struct depth(());
     }
 }
 
@@ -437,9 +437,9 @@ where
 impl<S: BosStr, St> ThreadItemBuilder<S, St>
 where
     St: thread_item_state::State,
-    St::Depth: thread_item_state::IsSet,
     St::Uri: thread_item_state::IsSet,
     St::Value: thread_item_state::IsSet,
+    St::Depth: thread_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ThreadItem<S> {
diff --git a/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs b/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs
index 5a8c2327..0ec71d6e 100644
--- a/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs
+++ b/crates/jacquard-api/src/app_bsky/unspecced/get_tagged_suggestions.rs
@@ -178,51 +178,51 @@ pub mod suggestion_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type SubjectType;
         type Tag;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type SubjectType = Unset;
         type Tag = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type SubjectType = St::SubjectType;
-        type Tag = St::Tag;
+        type Subject = Unset;
     }
     ///State transition - sets the `subject_type` field to Set
     pub struct SetSubjectType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubjectType<St> {}
     impl<St: State> State for SetSubjectType<St> {
-        type Subject = St::Subject;
         type SubjectType = Set<members::subject_type>;
         type Tag = St::Tag;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `tag` field to Set
     pub struct SetTag<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTag<St> {}
     impl<St: State> State for SetTag<St> {
-        type Subject = St::Subject;
         type SubjectType = St::SubjectType;
         type Tag = Set<members::tag>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type SubjectType = St::SubjectType;
+        type Tag = St::Tag;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `subject_type` field
         pub struct subject_type(());
         ///Marker type for the `tag` field
         pub struct tag(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -311,9 +311,9 @@ where
 impl<S: BosStr, St> SuggestionBuilder<S, St>
 where
     St: suggestion_state::State,
-    St::Subject: suggestion_state::IsSet,
     St::SubjectType: suggestion_state::IsSet,
     St::Tag: suggestion_state::IsSet,
+    St::Subject: suggestion_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Suggestion<S> {
diff --git a/crates/jacquard-api/src/app_bsky/video.rs b/crates/jacquard-api/src/app_bsky/video.rs
index ddd6edb5..3ce747e8 100644
--- a/crates/jacquard-api/src/app_bsky/video.rs
+++ b/crates/jacquard-api/src/app_bsky/video.rs
@@ -173,51 +173,51 @@ pub mod job_status_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type JobId;
         type Did;
         type State;
+        type JobId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type JobId = Unset;
         type Did = Unset;
         type State = Unset;
-    }
-    ///State transition - sets the `job_id` field to Set
-    pub struct SetJobId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetJobId<St> {}
-    impl<St: State> State for SetJobId<St> {
-        type JobId = Set<members::job_id>;
-        type Did = St::Did;
-        type State = St::State;
+        type JobId = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type JobId = St::JobId;
         type Did = Set<members::did>;
         type State = St::State;
+        type JobId = St::JobId;
     }
     ///State transition - sets the `state` field to Set
     pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetState<St> {}
     impl<St: State> State for SetState<St> {
-        type JobId = St::JobId;
         type Did = St::Did;
         type State = Set<members::state>;
+        type JobId = St::JobId;
+    }
+    ///State transition - sets the `job_id` field to Set
+    pub struct SetJobId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetJobId<St> {}
+    impl<St: State> State for SetJobId<St> {
+        type Did = St::Did;
+        type State = St::State;
+        type JobId = Set<members::job_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `job_id` field
-        pub struct job_id(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `state` field
         pub struct state(());
+        ///Marker type for the `job_id` field
+        pub struct job_id(());
     }
 }
 
@@ -366,9 +366,9 @@ where
 impl<S: BosStr, St> JobStatusBuilder<S, St>
 where
     St: job_status_state::State,
-    St::JobId: job_status_state::IsSet,
     St::Did: job_status_state::IsSet,
     St::State: job_status_state::IsSet,
+    St::JobId: job_status_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> JobStatus<S> {
diff --git a/crates/jacquard-api/src/app_bsky/video/upload_video.rs b/crates/jacquard-api/src/app_bsky/video/upload_video.rs
index 469516bb..56f47ee0 100644
--- a/crates/jacquard-api/src/app_bsky/video/upload_video.rs
+++ b/crates/jacquard-api/src/app_bsky/video/upload_video.rs
@@ -8,15 +8,15 @@
 #[allow(unused_imports)]
 use alloc::collections::BTreeMap;
 
+use crate::app_bsky::video::JobStatus;
 #[allow(unused_imports)]
 use core::marker::PhantomData;
-use jacquard_common::{BosStr, DefaultStr, FromStaticStr};
 use jacquard_common::deps::bytes::Bytes;
 use jacquard_common::deps::smol_str::SmolStr;
 use jacquard_common::types::value::Data;
+use jacquard_common::{BosStr, DefaultStr, FromStaticStr};
 use jacquard_derive::IntoStatic;
-use serde::{Serialize, Deserialize};
-use crate::app_bsky::video::JobStatus;
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
 #[serde(rename_all = "camelCase")]
@@ -24,9 +24,11 @@ pub struct UploadVideo {
     pub body: Bytes,
 }
 
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
-#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+#[serde(
+    rename_all = "camelCase",
+    bound(deserialize = "S: Deserialize<'de> + BosStr")
+)]
 pub struct UploadVideoOutput<S: BosStr = DefaultStr> {
     pub job_status: JobStatus<S>,
     #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
@@ -44,22 +46,16 @@ impl jacquard_common::xrpc::XrpcResp for UploadVideoResponse {
 
 impl jacquard_common::xrpc::XrpcRequest for UploadVideo {
     const NSID: &'static str = "app.bsky.video.uploadVideo";
-    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
-        "video/mp4",
-    );
+    const METHOD: jacquard_common::xrpc::XrpcMethod =
+        jacquard_common::xrpc::XrpcMethod::Procedure("video/mp4");
     type Response = UploadVideoResponse;
-    fn encode_body(
-        &self,
-        buffer: &mut [u8],
-    ) -> Result<(), jacquard_common::xrpc::EncodeError>
+    fn encode_body(&self, buffer: &mut Vec<u8>) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
     {
         Ok(buffer.copy_from_slice(self.body.as_ref()))
     }
-    fn decode_body<'de>(
-        body: &'de [u8],
-    ) -> Result<Self, jacquard_common::error::DecodeError>
+    fn decode_body<'de>(body: &'de [u8]) -> Result<Self, jacquard_common::error::DecodeError>
     where
         Self: Deserialize<'de>,
     {
@@ -73,9 +69,8 @@ impl jacquard_common::xrpc::XrpcRequest for UploadVideo {
 pub struct UploadVideoRequest;
 impl jacquard_common::xrpc::XrpcEndpoint for UploadVideoRequest {
     const PATH: &'static str = "/xrpc/app.bsky.video.uploadVideo";
-    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
-        "video/mp4",
-    );
+    const METHOD: jacquard_common::xrpc::XrpcMethod =
+        jacquard_common::xrpc::XrpcMethod::Procedure("video/mp4");
     type Request<S: BosStr> = UploadVideo;
     type Response = UploadVideoResponse;
-}
\ No newline at end of file
+}
diff --git a/crates/jacquard-api/src/app_certified/badge/award.rs b/crates/jacquard-api/src/app_certified/badge/award.rs
index 4027b11b..035eb4e3 100644
--- a/crates/jacquard-api/src/app_certified/badge/award.rs
+++ b/crates/jacquard-api/src/app_certified/badge/award.rs
@@ -156,51 +156,51 @@ pub mod award_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Subject;
         type CreatedAt;
         type Badge;
-        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Subject = Unset;
         type CreatedAt = Unset;
         type Badge = Unset;
-        type Subject = Unset;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+        type Badge = St::Badge;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
         type Badge = St::Badge;
-        type Subject = St::Subject;
     }
     ///State transition - sets the `badge` field to Set
     pub struct SetBadge<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBadge<St> {}
     impl<St: State> State for SetBadge<St> {
-        type CreatedAt = St::CreatedAt;
-        type Badge = Set<members::badge>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type CreatedAt = St::CreatedAt;
-        type Badge = St::Badge;
-        type Subject = Set<members::subject>;
+        type Badge = Set<members::badge>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `badge` field
         pub struct badge(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
     }
 }
 
@@ -321,9 +321,9 @@ impl<S: BosStr, St: award_state::State> AwardBuilder<S, St> {
 impl<S: BosStr, St> AwardBuilder<S, St>
 where
     St: award_state::State,
+    St::Subject: award_state::IsSet,
     St::CreatedAt: award_state::IsSet,
     St::Badge: award_state::IsSet,
-    St::Subject: award_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Award<S> {
diff --git a/crates/jacquard-api/src/app_certified/badge/definition.rs b/crates/jacquard-api/src/app_certified/badge/definition.rs
index 11860700..62e5bc4f 100644
--- a/crates/jacquard-api/src/app_certified/badge/definition.rs
+++ b/crates/jacquard-api/src/app_certified/badge/definition.rs
@@ -228,67 +228,67 @@ pub mod definition_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type BadgeType;
         type Title;
-        type CreatedAt;
         type Icon;
+        type BadgeType;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type BadgeType = Unset;
         type Title = Unset;
-        type CreatedAt = Unset;
         type Icon = Unset;
-    }
-    ///State transition - sets the `badge_type` field to Set
-    pub struct SetBadgeType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBadgeType<St> {}
-    impl<St: State> State for SetBadgeType<St> {
-        type BadgeType = Set<members::badge_type>;
-        type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-        type Icon = St::Icon;
+        type BadgeType = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type BadgeType = St::BadgeType;
         type Title = Set<members::title>;
-        type CreatedAt = St::CreatedAt;
         type Icon = St::Icon;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type BadgeType = St::BadgeType;
-        type Title = St::Title;
-        type CreatedAt = Set<members::created_at>;
-        type Icon = St::Icon;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `icon` field to Set
     pub struct SetIcon<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIcon<St> {}
     impl<St: State> State for SetIcon<St> {
+        type Title = St::Title;
+        type Icon = Set<members::icon>;
         type BadgeType = St::BadgeType;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `badge_type` field to Set
+    pub struct SetBadgeType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBadgeType<St> {}
+    impl<St: State> State for SetBadgeType<St> {
         type Title = St::Title;
+        type Icon = St::Icon;
+        type BadgeType = Set<members::badge_type>;
         type CreatedAt = St::CreatedAt;
-        type Icon = Set<members::icon>;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type Icon = St::Icon;
+        type BadgeType = St::BadgeType;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `badge_type` field
-        pub struct badge_type(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `icon` field
         pub struct icon(());
+        ///Marker type for the `badge_type` field
+        pub struct badge_type(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -429,10 +429,10 @@ where
 impl<S: BosStr, St> DefinitionBuilder<S, St>
 where
     St: definition_state::State,
-    St::BadgeType: definition_state::IsSet,
     St::Title: definition_state::IsSet,
-    St::CreatedAt: definition_state::IsSet,
     St::Icon: definition_state::IsSet,
+    St::BadgeType: definition_state::IsSet,
+    St::CreatedAt: definition_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Definition<S> {
diff --git a/crates/jacquard-api/src/app_certified/location.rs b/crates/jacquard-api/src/app_certified/location.rs
index eb00f28b..1dbd61dd 100644
--- a/crates/jacquard-api/src/app_certified/location.rs
+++ b/crates/jacquard-api/src/app_certified/location.rs
@@ -378,83 +378,83 @@ pub mod location_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type LpVersion;
         type Srs;
         type LocationType;
+        type CreatedAt;
+        type LpVersion;
         type Location;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type LpVersion = Unset;
         type Srs = Unset;
         type LocationType = Unset;
+        type CreatedAt = Unset;
+        type LpVersion = Unset;
         type Location = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type LpVersion = St::LpVersion;
-        type Srs = St::Srs;
-        type LocationType = St::LocationType;
-        type Location = St::Location;
-    }
-    ///State transition - sets the `lp_version` field to Set
-    pub struct SetLpVersion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLpVersion<St> {}
-    impl<St: State> State for SetLpVersion<St> {
-        type CreatedAt = St::CreatedAt;
-        type LpVersion = Set<members::lp_version>;
-        type Srs = St::Srs;
-        type LocationType = St::LocationType;
-        type Location = St::Location;
-    }
     ///State transition - sets the `srs` field to Set
     pub struct SetSrs<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSrs<St> {}
     impl<St: State> State for SetSrs<St> {
-        type CreatedAt = St::CreatedAt;
-        type LpVersion = St::LpVersion;
         type Srs = Set<members::srs>;
         type LocationType = St::LocationType;
+        type CreatedAt = St::CreatedAt;
+        type LpVersion = St::LpVersion;
         type Location = St::Location;
     }
     ///State transition - sets the `location_type` field to Set
     pub struct SetLocationType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLocationType<St> {}
     impl<St: State> State for SetLocationType<St> {
+        type Srs = St::Srs;
+        type LocationType = Set<members::location_type>;
         type CreatedAt = St::CreatedAt;
         type LpVersion = St::LpVersion;
+        type Location = St::Location;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Srs = St::Srs;
+        type LocationType = St::LocationType;
+        type CreatedAt = Set<members::created_at>;
+        type LpVersion = St::LpVersion;
+        type Location = St::Location;
+    }
+    ///State transition - sets the `lp_version` field to Set
+    pub struct SetLpVersion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLpVersion<St> {}
+    impl<St: State> State for SetLpVersion<St> {
         type Srs = St::Srs;
-        type LocationType = Set<members::location_type>;
+        type LocationType = St::LocationType;
+        type CreatedAt = St::CreatedAt;
+        type LpVersion = Set<members::lp_version>;
         type Location = St::Location;
     }
     ///State transition - sets the `location` field to Set
     pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLocation<St> {}
     impl<St: State> State for SetLocation<St> {
-        type CreatedAt = St::CreatedAt;
-        type LpVersion = St::LpVersion;
         type Srs = St::Srs;
         type LocationType = St::LocationType;
+        type CreatedAt = St::CreatedAt;
+        type LpVersion = St::LpVersion;
         type Location = Set<members::location>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `lp_version` field
-        pub struct lp_version(());
         ///Marker type for the `srs` field
         pub struct srs(());
         ///Marker type for the `location_type` field
         pub struct location_type(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `lp_version` field
+        pub struct lp_version(());
         ///Marker type for the `location` field
         pub struct location(());
     }
@@ -617,10 +617,10 @@ where
 impl<S: BosStr, St> LocationBuilder<S, St>
 where
     St: location_state::State,
-    St::CreatedAt: location_state::IsSet,
-    St::LpVersion: location_state::IsSet,
     St::Srs: location_state::IsSet,
     St::LocationType: location_state::IsSet,
+    St::CreatedAt: location_state::IsSet,
+    St::LpVersion: location_state::IsSet,
     St::Location: location_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_chavatar/settings.rs b/crates/jacquard-api/src/app_chavatar/settings.rs
index 81ece5d6..b8ad4a40 100644
--- a/crates/jacquard-api/src/app_chavatar/settings.rs
+++ b/crates/jacquard-api/src/app_chavatar/settings.rs
@@ -585,8 +585,8 @@ pub mod settings_state {
     pub trait State: sealed::Sealed {
         type Avatars;
         type Enabled;
-        type Mode;
         type Interval;
+        type Mode;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -594,8 +594,8 @@ pub mod settings_state {
     impl State for Empty {
         type Avatars = Unset;
         type Enabled = Unset;
-        type Mode = Unset;
         type Interval = Unset;
+        type Mode = Unset;
     }
     ///State transition - sets the `avatars` field to Set
     pub struct SetAvatars<St: State = Empty>(PhantomData<fn() -> St>);
@@ -603,8 +603,8 @@ pub mod settings_state {
     impl<St: State> State for SetAvatars<St> {
         type Avatars = Set<members::avatars>;
         type Enabled = St::Enabled;
-        type Mode = St::Mode;
         type Interval = St::Interval;
+        type Mode = St::Mode;
     }
     ///State transition - sets the `enabled` field to Set
     pub struct SetEnabled<St: State = Empty>(PhantomData<fn() -> St>);
@@ -612,17 +612,8 @@ pub mod settings_state {
     impl<St: State> State for SetEnabled<St> {
         type Avatars = St::Avatars;
         type Enabled = Set<members::enabled>;
-        type Mode = St::Mode;
-        type Interval = St::Interval;
-    }
-    ///State transition - sets the `mode` field to Set
-    pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMode<St> {}
-    impl<St: State> State for SetMode<St> {
-        type Avatars = St::Avatars;
-        type Enabled = St::Enabled;
-        type Mode = Set<members::mode>;
         type Interval = St::Interval;
+        type Mode = St::Mode;
     }
     ///State transition - sets the `interval` field to Set
     pub struct SetInterval<St: State = Empty>(PhantomData<fn() -> St>);
@@ -630,8 +621,17 @@ pub mod settings_state {
     impl<St: State> State for SetInterval<St> {
         type Avatars = St::Avatars;
         type Enabled = St::Enabled;
-        type Mode = St::Mode;
         type Interval = Set<members::interval>;
+        type Mode = St::Mode;
+    }
+    ///State transition - sets the `mode` field to Set
+    pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMode<St> {}
+    impl<St: State> State for SetMode<St> {
+        type Avatars = St::Avatars;
+        type Enabled = St::Enabled;
+        type Interval = St::Interval;
+        type Mode = Set<members::mode>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -640,10 +640,10 @@ pub mod settings_state {
         pub struct avatars(());
         ///Marker type for the `enabled` field
         pub struct enabled(());
-        ///Marker type for the `mode` field
-        pub struct mode(());
         ///Marker type for the `interval` field
         pub struct interval(());
+        ///Marker type for the `mode` field
+        pub struct mode(());
     }
 }
 
@@ -758,8 +758,8 @@ where
     St: settings_state::State,
     St::Avatars: settings_state::IsSet,
     St::Enabled: settings_state::IsSet,
-    St::Mode: settings_state::IsSet,
     St::Interval: settings_state::IsSet,
+    St::Mode: settings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Settings<S> {
diff --git a/crates/jacquard-api/src/app_chavatar/state.rs b/crates/jacquard-api/src/app_chavatar/state.rs
index 3315a54b..d8567a48 100644
--- a/crates/jacquard-api/src/app_chavatar/state.rs
+++ b/crates/jacquard-api/src/app_chavatar/state.rs
@@ -125,37 +125,37 @@ pub mod state_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type LastUpdated;
         type Cursor;
+        type LastUpdated;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type LastUpdated = Unset;
         type Cursor = Unset;
-    }
-    ///State transition - sets the `last_updated` field to Set
-    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
-    impl<St: State> State for SetLastUpdated<St> {
-        type LastUpdated = Set<members::last_updated>;
-        type Cursor = St::Cursor;
+        type LastUpdated = Unset;
     }
     ///State transition - sets the `cursor` field to Set
     pub struct SetCursor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCursor<St> {}
     impl<St: State> State for SetCursor<St> {
-        type LastUpdated = St::LastUpdated;
         type Cursor = Set<members::cursor>;
+        type LastUpdated = St::LastUpdated;
+    }
+    ///State transition - sets the `last_updated` field to Set
+    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
+    impl<St: State> State for SetLastUpdated<St> {
+        type Cursor = St::Cursor;
+        type LastUpdated = Set<members::last_updated>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `last_updated` field
-        pub struct last_updated(());
         ///Marker type for the `cursor` field
         pub struct cursor(());
+        ///Marker type for the `last_updated` field
+        pub struct last_updated(());
     }
 }
 
@@ -225,8 +225,8 @@ where
 impl<S: BosStr, St> StateBuilder<S, St>
 where
     St: state_state::State,
-    St::LastUpdated: state_state::IsSet,
     St::Cursor: state_state::IsSet,
+    St::LastUpdated: state_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> State<S> {
diff --git a/crates/jacquard-api/src/app_chronosky/media/upload_blob.rs b/crates/jacquard-api/src/app_chronosky/media/upload_blob.rs
index cdcc68c6..dc18acd6 100644
--- a/crates/jacquard-api/src/app_chronosky/media/upload_blob.rs
+++ b/crates/jacquard-api/src/app_chronosky/media/upload_blob.rs
@@ -121,7 +121,7 @@ impl jacquard_common::xrpc::XrpcRequest for UploadBlob {
     type Response = UploadBlobResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/app_chronosky/plan/get_assignment.rs b/crates/jacquard-api/src/app_chronosky/plan/get_assignment.rs
index 0a6bca56..bbbf4997 100644
--- a/crates/jacquard-api/src/app_chronosky/plan/get_assignment.rs
+++ b/crates/jacquard-api/src/app_chronosky/plan/get_assignment.rs
@@ -279,105 +279,105 @@ pub mod plan_assignment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Id;
         type ActivatedAt;
-        type PlanId;
-        type ExpiresAt;
+        type Id;
         type Status;
         type Plan;
+        type ExpiresAt;
+        type PlanId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Id = Unset;
         type ActivatedAt = Unset;
-        type PlanId = Unset;
-        type ExpiresAt = Unset;
+        type Id = Unset;
         type Status = Unset;
         type Plan = Unset;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
-        type ActivatedAt = St::ActivatedAt;
-        type PlanId = St::PlanId;
-        type ExpiresAt = St::ExpiresAt;
-        type Status = St::Status;
-        type Plan = St::Plan;
+        type ExpiresAt = Unset;
+        type PlanId = Unset;
     }
     ///State transition - sets the `activated_at` field to Set
     pub struct SetActivatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActivatedAt<St> {}
     impl<St: State> State for SetActivatedAt<St> {
-        type Id = St::Id;
         type ActivatedAt = Set<members::activated_at>;
-        type PlanId = St::PlanId;
-        type ExpiresAt = St::ExpiresAt;
-        type Status = St::Status;
-        type Plan = St::Plan;
-    }
-    ///State transition - sets the `plan_id` field to Set
-    pub struct SetPlanId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlanId<St> {}
-    impl<St: State> State for SetPlanId<St> {
         type Id = St::Id;
-        type ActivatedAt = St::ActivatedAt;
-        type PlanId = Set<members::plan_id>;
-        type ExpiresAt = St::ExpiresAt;
         type Status = St::Status;
         type Plan = St::Plan;
+        type ExpiresAt = St::ExpiresAt;
+        type PlanId = St::PlanId;
     }
-    ///State transition - sets the `expires_at` field to Set
-    pub struct SetExpiresAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetExpiresAt<St> {}
-    impl<St: State> State for SetExpiresAt<St> {
-        type Id = St::Id;
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
         type ActivatedAt = St::ActivatedAt;
-        type PlanId = St::PlanId;
-        type ExpiresAt = Set<members::expires_at>;
+        type Id = Set<members::id>;
         type Status = St::Status;
         type Plan = St::Plan;
+        type ExpiresAt = St::ExpiresAt;
+        type PlanId = St::PlanId;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type Id = St::Id;
         type ActivatedAt = St::ActivatedAt;
-        type PlanId = St::PlanId;
-        type ExpiresAt = St::ExpiresAt;
+        type Id = St::Id;
         type Status = Set<members::status>;
         type Plan = St::Plan;
+        type ExpiresAt = St::ExpiresAt;
+        type PlanId = St::PlanId;
     }
     ///State transition - sets the `plan` field to Set
     pub struct SetPlan<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlan<St> {}
     impl<St: State> State for SetPlan<St> {
+        type ActivatedAt = St::ActivatedAt;
         type Id = St::Id;
+        type Status = St::Status;
+        type Plan = Set<members::plan>;
+        type ExpiresAt = St::ExpiresAt;
+        type PlanId = St::PlanId;
+    }
+    ///State transition - sets the `expires_at` field to Set
+    pub struct SetExpiresAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetExpiresAt<St> {}
+    impl<St: State> State for SetExpiresAt<St> {
         type ActivatedAt = St::ActivatedAt;
+        type Id = St::Id;
+        type Status = St::Status;
+        type Plan = St::Plan;
+        type ExpiresAt = Set<members::expires_at>;
         type PlanId = St::PlanId;
-        type ExpiresAt = St::ExpiresAt;
+    }
+    ///State transition - sets the `plan_id` field to Set
+    pub struct SetPlanId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlanId<St> {}
+    impl<St: State> State for SetPlanId<St> {
+        type ActivatedAt = St::ActivatedAt;
+        type Id = St::Id;
         type Status = St::Status;
-        type Plan = Set<members::plan>;
+        type Plan = St::Plan;
+        type ExpiresAt = St::ExpiresAt;
+        type PlanId = Set<members::plan_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `activated_at` field
         pub struct activated_at(());
-        ///Marker type for the `plan_id` field
-        pub struct plan_id(());
-        ///Marker type for the `expires_at` field
-        pub struct expires_at(());
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `status` field
         pub struct status(());
         ///Marker type for the `plan` field
         pub struct plan(());
+        ///Marker type for the `expires_at` field
+        pub struct expires_at(());
+        ///Marker type for the `plan_id` field
+        pub struct plan_id(());
     }
 }
 
@@ -547,12 +547,12 @@ impl<S: BosStr, St: plan_assignment_state::State> PlanAssignmentBuilder<S, St> {
 impl<S: BosStr, St> PlanAssignmentBuilder<S, St>
 where
     St: plan_assignment_state::State,
-    St::Id: plan_assignment_state::IsSet,
     St::ActivatedAt: plan_assignment_state::IsSet,
-    St::PlanId: plan_assignment_state::IsSet,
-    St::ExpiresAt: plan_assignment_state::IsSet,
+    St::Id: plan_assignment_state::IsSet,
     St::Status: plan_assignment_state::IsSet,
     St::Plan: plan_assignment_state::IsSet,
+    St::ExpiresAt: plan_assignment_state::IsSet,
+    St::PlanId: plan_assignment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlanAssignment<S> {
diff --git a/crates/jacquard-api/src/app_chronosky/plan/get_usage.rs b/crates/jacquard-api/src/app_chronosky/plan/get_usage.rs
index f8ea6391..1f61d5ad 100644
--- a/crates/jacquard-api/src/app_chronosky/plan/get_usage.rs
+++ b/crates/jacquard-api/src/app_chronosky/plan/get_usage.rs
@@ -238,85 +238,85 @@ pub mod current_plan_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type DisplayName;
-        type Id;
         type Name;
         type IsActive;
         type Tier;
+        type DisplayName;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type DisplayName = Unset;
-        type Id = Unset;
         type Name = Unset;
         type IsActive = Unset;
         type Tier = Unset;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
-        type DisplayName = Set<members::display_name>;
-        type Id = St::Id;
-        type Name = St::Name;
-        type IsActive = St::IsActive;
-        type Tier = St::Tier;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type DisplayName = St::DisplayName;
-        type Id = Set<members::id>;
-        type Name = St::Name;
-        type IsActive = St::IsActive;
-        type Tier = St::Tier;
+        type DisplayName = Unset;
+        type Id = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type DisplayName = St::DisplayName;
-        type Id = St::Id;
         type Name = Set<members::name>;
         type IsActive = St::IsActive;
         type Tier = St::Tier;
+        type DisplayName = St::DisplayName;
+        type Id = St::Id;
     }
     ///State transition - sets the `is_active` field to Set
     pub struct SetIsActive<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIsActive<St> {}
     impl<St: State> State for SetIsActive<St> {
-        type DisplayName = St::DisplayName;
-        type Id = St::Id;
         type Name = St::Name;
         type IsActive = Set<members::is_active>;
         type Tier = St::Tier;
+        type DisplayName = St::DisplayName;
+        type Id = St::Id;
     }
     ///State transition - sets the `tier` field to Set
     pub struct SetTier<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTier<St> {}
     impl<St: State> State for SetTier<St> {
+        type Name = St::Name;
+        type IsActive = St::IsActive;
+        type Tier = Set<members::tier>;
         type DisplayName = St::DisplayName;
         type Id = St::Id;
+    }
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
         type Name = St::Name;
         type IsActive = St::IsActive;
-        type Tier = Set<members::tier>;
+        type Tier = St::Tier;
+        type DisplayName = Set<members::display_name>;
+        type Id = St::Id;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Name = St::Name;
+        type IsActive = St::IsActive;
+        type Tier = St::Tier;
+        type DisplayName = St::DisplayName;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `is_active` field
         pub struct is_active(());
         ///Marker type for the `tier` field
         pub struct tier(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -463,11 +463,11 @@ impl<S: BosStr, St: current_plan_state::State> CurrentPlanBuilder<S, St> {
 impl<S: BosStr, St> CurrentPlanBuilder<S, St>
 where
     St: current_plan_state::State,
-    St::DisplayName: current_plan_state::IsSet,
-    St::Id: current_plan_state::IsSet,
     St::Name: current_plan_state::IsSet,
     St::IsActive: current_plan_state::IsSet,
     St::Tier: current_plan_state::IsSet,
+    St::DisplayName: current_plan_state::IsSet,
+    St::Id: current_plan_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CurrentPlan<S> {
@@ -778,105 +778,105 @@ pub mod plan_limits_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MaxScheduleDays;
-        type ThreadPostsLimit;
-        type MaxImagesPerPost;
         type ScheduleIntervalMinutes;
-        type PendingPostsLimit;
+        type MaxImagesPerPost;
         type MonthlyPostsLimit;
+        type MaxScheduleDays;
+        type PendingPostsLimit;
+        type ThreadPostsLimit;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MaxScheduleDays = Unset;
-        type ThreadPostsLimit = Unset;
-        type MaxImagesPerPost = Unset;
         type ScheduleIntervalMinutes = Unset;
-        type PendingPostsLimit = Unset;
+        type MaxImagesPerPost = Unset;
         type MonthlyPostsLimit = Unset;
+        type MaxScheduleDays = Unset;
+        type PendingPostsLimit = Unset;
+        type ThreadPostsLimit = Unset;
     }
-    ///State transition - sets the `max_schedule_days` field to Set
-    pub struct SetMaxScheduleDays<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMaxScheduleDays<St> {}
-    impl<St: State> State for SetMaxScheduleDays<St> {
-        type MaxScheduleDays = Set<members::max_schedule_days>;
-        type ThreadPostsLimit = St::ThreadPostsLimit;
+    ///State transition - sets the `schedule_interval_minutes` field to Set
+    pub struct SetScheduleIntervalMinutes<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScheduleIntervalMinutes<St> {}
+    impl<St: State> State for SetScheduleIntervalMinutes<St> {
+        type ScheduleIntervalMinutes = Set<members::schedule_interval_minutes>;
         type MaxImagesPerPost = St::MaxImagesPerPost;
-        type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
-        type PendingPostsLimit = St::PendingPostsLimit;
         type MonthlyPostsLimit = St::MonthlyPostsLimit;
-    }
-    ///State transition - sets the `thread_posts_limit` field to Set
-    pub struct SetThreadPostsLimit<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetThreadPostsLimit<St> {}
-    impl<St: State> State for SetThreadPostsLimit<St> {
         type MaxScheduleDays = St::MaxScheduleDays;
-        type ThreadPostsLimit = Set<members::thread_posts_limit>;
-        type MaxImagesPerPost = St::MaxImagesPerPost;
-        type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
         type PendingPostsLimit = St::PendingPostsLimit;
-        type MonthlyPostsLimit = St::MonthlyPostsLimit;
+        type ThreadPostsLimit = St::ThreadPostsLimit;
     }
     ///State transition - sets the `max_images_per_post` field to Set
     pub struct SetMaxImagesPerPost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMaxImagesPerPost<St> {}
     impl<St: State> State for SetMaxImagesPerPost<St> {
-        type MaxScheduleDays = St::MaxScheduleDays;
-        type ThreadPostsLimit = St::ThreadPostsLimit;
-        type MaxImagesPerPost = Set<members::max_images_per_post>;
         type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
-        type PendingPostsLimit = St::PendingPostsLimit;
+        type MaxImagesPerPost = Set<members::max_images_per_post>;
         type MonthlyPostsLimit = St::MonthlyPostsLimit;
-    }
-    ///State transition - sets the `schedule_interval_minutes` field to Set
-    pub struct SetScheduleIntervalMinutes<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScheduleIntervalMinutes<St> {}
-    impl<St: State> State for SetScheduleIntervalMinutes<St> {
         type MaxScheduleDays = St::MaxScheduleDays;
+        type PendingPostsLimit = St::PendingPostsLimit;
         type ThreadPostsLimit = St::ThreadPostsLimit;
+    }
+    ///State transition - sets the `monthly_posts_limit` field to Set
+    pub struct SetMonthlyPostsLimit<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMonthlyPostsLimit<St> {}
+    impl<St: State> State for SetMonthlyPostsLimit<St> {
+        type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
         type MaxImagesPerPost = St::MaxImagesPerPost;
-        type ScheduleIntervalMinutes = Set<members::schedule_interval_minutes>;
+        type MonthlyPostsLimit = Set<members::monthly_posts_limit>;
+        type MaxScheduleDays = St::MaxScheduleDays;
         type PendingPostsLimit = St::PendingPostsLimit;
+        type ThreadPostsLimit = St::ThreadPostsLimit;
+    }
+    ///State transition - sets the `max_schedule_days` field to Set
+    pub struct SetMaxScheduleDays<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMaxScheduleDays<St> {}
+    impl<St: State> State for SetMaxScheduleDays<St> {
+        type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
+        type MaxImagesPerPost = St::MaxImagesPerPost;
         type MonthlyPostsLimit = St::MonthlyPostsLimit;
+        type MaxScheduleDays = Set<members::max_schedule_days>;
+        type PendingPostsLimit = St::PendingPostsLimit;
+        type ThreadPostsLimit = St::ThreadPostsLimit;
     }
     ///State transition - sets the `pending_posts_limit` field to Set
     pub struct SetPendingPostsLimit<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPendingPostsLimit<St> {}
     impl<St: State> State for SetPendingPostsLimit<St> {
-        type MaxScheduleDays = St::MaxScheduleDays;
-        type ThreadPostsLimit = St::ThreadPostsLimit;
-        type MaxImagesPerPost = St::MaxImagesPerPost;
         type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
-        type PendingPostsLimit = Set<members::pending_posts_limit>;
+        type MaxImagesPerPost = St::MaxImagesPerPost;
         type MonthlyPostsLimit = St::MonthlyPostsLimit;
-    }
-    ///State transition - sets the `monthly_posts_limit` field to Set
-    pub struct SetMonthlyPostsLimit<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMonthlyPostsLimit<St> {}
-    impl<St: State> State for SetMonthlyPostsLimit<St> {
         type MaxScheduleDays = St::MaxScheduleDays;
+        type PendingPostsLimit = Set<members::pending_posts_limit>;
         type ThreadPostsLimit = St::ThreadPostsLimit;
-        type MaxImagesPerPost = St::MaxImagesPerPost;
+    }
+    ///State transition - sets the `thread_posts_limit` field to Set
+    pub struct SetThreadPostsLimit<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetThreadPostsLimit<St> {}
+    impl<St: State> State for SetThreadPostsLimit<St> {
         type ScheduleIntervalMinutes = St::ScheduleIntervalMinutes;
+        type MaxImagesPerPost = St::MaxImagesPerPost;
+        type MonthlyPostsLimit = St::MonthlyPostsLimit;
+        type MaxScheduleDays = St::MaxScheduleDays;
         type PendingPostsLimit = St::PendingPostsLimit;
-        type MonthlyPostsLimit = Set<members::monthly_posts_limit>;
+        type ThreadPostsLimit = Set<members::thread_posts_limit>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `max_schedule_days` field
-        pub struct max_schedule_days(());
-        ///Marker type for the `thread_posts_limit` field
-        pub struct thread_posts_limit(());
-        ///Marker type for the `max_images_per_post` field
-        pub struct max_images_per_post(());
         ///Marker type for the `schedule_interval_minutes` field
         pub struct schedule_interval_minutes(());
-        ///Marker type for the `pending_posts_limit` field
-        pub struct pending_posts_limit(());
+        ///Marker type for the `max_images_per_post` field
+        pub struct max_images_per_post(());
         ///Marker type for the `monthly_posts_limit` field
         pub struct monthly_posts_limit(());
+        ///Marker type for the `max_schedule_days` field
+        pub struct max_schedule_days(());
+        ///Marker type for the `pending_posts_limit` field
+        pub struct pending_posts_limit(());
+        ///Marker type for the `thread_posts_limit` field
+        pub struct thread_posts_limit(());
     }
 }
 
@@ -1129,12 +1129,12 @@ impl<S: BosStr, St: plan_limits_state::State> PlanLimitsBuilder<S, St> {
 impl<S: BosStr, St> PlanLimitsBuilder<S, St>
 where
     St: plan_limits_state::State,
-    St::MaxScheduleDays: plan_limits_state::IsSet,
-    St::ThreadPostsLimit: plan_limits_state::IsSet,
-    St::MaxImagesPerPost: plan_limits_state::IsSet,
     St::ScheduleIntervalMinutes: plan_limits_state::IsSet,
-    St::PendingPostsLimit: plan_limits_state::IsSet,
+    St::MaxImagesPerPost: plan_limits_state::IsSet,
     St::MonthlyPostsLimit: plan_limits_state::IsSet,
+    St::MaxScheduleDays: plan_limits_state::IsSet,
+    St::PendingPostsLimit: plan_limits_state::IsSet,
+    St::ThreadPostsLimit: plan_limits_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlanLimits<S> {
@@ -1187,85 +1187,85 @@ pub mod usage_stats_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type PendingPostsCount;
-        type LastUpdated;
+        type MonthlyPeriodEnd;
         type MonthlyPostsCount;
         type MonthlyPeriodStart;
-        type MonthlyPeriodEnd;
+        type PendingPostsCount;
+        type LastUpdated;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type PendingPostsCount = Unset;
-        type LastUpdated = Unset;
+        type MonthlyPeriodEnd = Unset;
         type MonthlyPostsCount = Unset;
         type MonthlyPeriodStart = Unset;
-        type MonthlyPeriodEnd = Unset;
+        type PendingPostsCount = Unset;
+        type LastUpdated = Unset;
     }
-    ///State transition - sets the `pending_posts_count` field to Set
-    pub struct SetPendingPostsCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPendingPostsCount<St> {}
-    impl<St: State> State for SetPendingPostsCount<St> {
-        type PendingPostsCount = Set<members::pending_posts_count>;
-        type LastUpdated = St::LastUpdated;
+    ///State transition - sets the `monthly_period_end` field to Set
+    pub struct SetMonthlyPeriodEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMonthlyPeriodEnd<St> {}
+    impl<St: State> State for SetMonthlyPeriodEnd<St> {
+        type MonthlyPeriodEnd = Set<members::monthly_period_end>;
         type MonthlyPostsCount = St::MonthlyPostsCount;
         type MonthlyPeriodStart = St::MonthlyPeriodStart;
-        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
-    }
-    ///State transition - sets the `last_updated` field to Set
-    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
-    impl<St: State> State for SetLastUpdated<St> {
         type PendingPostsCount = St::PendingPostsCount;
-        type LastUpdated = Set<members::last_updated>;
-        type MonthlyPostsCount = St::MonthlyPostsCount;
-        type MonthlyPeriodStart = St::MonthlyPeriodStart;
-        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
+        type LastUpdated = St::LastUpdated;
     }
     ///State transition - sets the `monthly_posts_count` field to Set
     pub struct SetMonthlyPostsCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMonthlyPostsCount<St> {}
     impl<St: State> State for SetMonthlyPostsCount<St> {
-        type PendingPostsCount = St::PendingPostsCount;
-        type LastUpdated = St::LastUpdated;
+        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
         type MonthlyPostsCount = Set<members::monthly_posts_count>;
         type MonthlyPeriodStart = St::MonthlyPeriodStart;
-        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
+        type PendingPostsCount = St::PendingPostsCount;
+        type LastUpdated = St::LastUpdated;
     }
     ///State transition - sets the `monthly_period_start` field to Set
     pub struct SetMonthlyPeriodStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMonthlyPeriodStart<St> {}
     impl<St: State> State for SetMonthlyPeriodStart<St> {
-        type PendingPostsCount = St::PendingPostsCount;
-        type LastUpdated = St::LastUpdated;
+        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
         type MonthlyPostsCount = St::MonthlyPostsCount;
         type MonthlyPeriodStart = Set<members::monthly_period_start>;
-        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
-    }
-    ///State transition - sets the `monthly_period_end` field to Set
-    pub struct SetMonthlyPeriodEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMonthlyPeriodEnd<St> {}
-    impl<St: State> State for SetMonthlyPeriodEnd<St> {
         type PendingPostsCount = St::PendingPostsCount;
         type LastUpdated = St::LastUpdated;
+    }
+    ///State transition - sets the `pending_posts_count` field to Set
+    pub struct SetPendingPostsCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPendingPostsCount<St> {}
+    impl<St: State> State for SetPendingPostsCount<St> {
+        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
+        type MonthlyPostsCount = St::MonthlyPostsCount;
+        type MonthlyPeriodStart = St::MonthlyPeriodStart;
+        type PendingPostsCount = Set<members::pending_posts_count>;
+        type LastUpdated = St::LastUpdated;
+    }
+    ///State transition - sets the `last_updated` field to Set
+    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
+    impl<St: State> State for SetLastUpdated<St> {
+        type MonthlyPeriodEnd = St::MonthlyPeriodEnd;
         type MonthlyPostsCount = St::MonthlyPostsCount;
         type MonthlyPeriodStart = St::MonthlyPeriodStart;
-        type MonthlyPeriodEnd = Set<members::monthly_period_end>;
+        type PendingPostsCount = St::PendingPostsCount;
+        type LastUpdated = Set<members::last_updated>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `pending_posts_count` field
-        pub struct pending_posts_count(());
-        ///Marker type for the `last_updated` field
-        pub struct last_updated(());
+        ///Marker type for the `monthly_period_end` field
+        pub struct monthly_period_end(());
         ///Marker type for the `monthly_posts_count` field
         pub struct monthly_posts_count(());
         ///Marker type for the `monthly_period_start` field
         pub struct monthly_period_start(());
-        ///Marker type for the `monthly_period_end` field
-        pub struct monthly_period_end(());
+        ///Marker type for the `pending_posts_count` field
+        pub struct pending_posts_count(());
+        ///Marker type for the `last_updated` field
+        pub struct last_updated(());
     }
 }
 
@@ -1426,11 +1426,11 @@ impl<S: BosStr, St: usage_stats_state::State> UsageStatsBuilder<S, St> {
 impl<S: BosStr, St> UsageStatsBuilder<S, St>
 where
     St: usage_stats_state::State,
-    St::PendingPostsCount: usage_stats_state::IsSet,
-    St::LastUpdated: usage_stats_state::IsSet,
+    St::MonthlyPeriodEnd: usage_stats_state::IsSet,
     St::MonthlyPostsCount: usage_stats_state::IsSet,
     St::MonthlyPeriodStart: usage_stats_state::IsSet,
-    St::MonthlyPeriodEnd: usage_stats_state::IsSet,
+    St::PendingPostsCount: usage_stats_state::IsSet,
+    St::LastUpdated: usage_stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UsageStats<S> {
diff --git a/crates/jacquard-api/src/app_chronosky/plan/redeem_ticket.rs b/crates/jacquard-api/src/app_chronosky/plan/redeem_ticket.rs
index c6d8131b..2a9191d0 100644
--- a/crates/jacquard-api/src/app_chronosky/plan/redeem_ticket.rs
+++ b/crates/jacquard-api/src/app_chronosky/plan/redeem_ticket.rs
@@ -214,85 +214,85 @@ pub mod redeemed_assignment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ExpiresAt;
-        type ActivatedAt;
+        type Status;
         type Id;
         type PlanId;
-        type Status;
+        type ActivatedAt;
+        type ExpiresAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ExpiresAt = Unset;
-        type ActivatedAt = Unset;
+        type Status = Unset;
         type Id = Unset;
         type PlanId = Unset;
-        type Status = Unset;
+        type ActivatedAt = Unset;
+        type ExpiresAt = Unset;
     }
-    ///State transition - sets the `expires_at` field to Set
-    pub struct SetExpiresAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetExpiresAt<St> {}
-    impl<St: State> State for SetExpiresAt<St> {
-        type ExpiresAt = Set<members::expires_at>;
-        type ActivatedAt = St::ActivatedAt;
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Status = Set<members::status>;
         type Id = St::Id;
         type PlanId = St::PlanId;
-        type Status = St::Status;
-    }
-    ///State transition - sets the `activated_at` field to Set
-    pub struct SetActivatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActivatedAt<St> {}
-    impl<St: State> State for SetActivatedAt<St> {
+        type ActivatedAt = St::ActivatedAt;
         type ExpiresAt = St::ExpiresAt;
-        type ActivatedAt = Set<members::activated_at>;
-        type Id = St::Id;
-        type PlanId = St::PlanId;
-        type Status = St::Status;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type ExpiresAt = St::ExpiresAt;
-        type ActivatedAt = St::ActivatedAt;
+        type Status = St::Status;
         type Id = Set<members::id>;
         type PlanId = St::PlanId;
-        type Status = St::Status;
+        type ActivatedAt = St::ActivatedAt;
+        type ExpiresAt = St::ExpiresAt;
     }
     ///State transition - sets the `plan_id` field to Set
     pub struct SetPlanId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlanId<St> {}
     impl<St: State> State for SetPlanId<St> {
-        type ExpiresAt = St::ExpiresAt;
-        type ActivatedAt = St::ActivatedAt;
+        type Status = St::Status;
         type Id = St::Id;
         type PlanId = Set<members::plan_id>;
-        type Status = St::Status;
+        type ActivatedAt = St::ActivatedAt;
+        type ExpiresAt = St::ExpiresAt;
     }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
+    ///State transition - sets the `activated_at` field to Set
+    pub struct SetActivatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActivatedAt<St> {}
+    impl<St: State> State for SetActivatedAt<St> {
+        type Status = St::Status;
+        type Id = St::Id;
+        type PlanId = St::PlanId;
+        type ActivatedAt = Set<members::activated_at>;
         type ExpiresAt = St::ExpiresAt;
-        type ActivatedAt = St::ActivatedAt;
+    }
+    ///State transition - sets the `expires_at` field to Set
+    pub struct SetExpiresAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetExpiresAt<St> {}
+    impl<St: State> State for SetExpiresAt<St> {
+        type Status = St::Status;
         type Id = St::Id;
         type PlanId = St::PlanId;
-        type Status = Set<members::status>;
+        type ActivatedAt = St::ActivatedAt;
+        type ExpiresAt = Set<members::expires_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `expires_at` field
-        pub struct expires_at(());
-        ///Marker type for the `activated_at` field
-        pub struct activated_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
         ///Marker type for the `id` field
         pub struct id(());
         ///Marker type for the `plan_id` field
         pub struct plan_id(());
-        ///Marker type for the `status` field
-        pub struct status(());
+        ///Marker type for the `activated_at` field
+        pub struct activated_at(());
+        ///Marker type for the `expires_at` field
+        pub struct expires_at(());
     }
 }
 
@@ -419,11 +419,11 @@ where
 impl<S: BosStr, St> RedeemedAssignmentBuilder<S, St>
 where
     St: redeemed_assignment_state::State,
-    St::ExpiresAt: redeemed_assignment_state::IsSet,
-    St::ActivatedAt: redeemed_assignment_state::IsSet,
+    St::Status: redeemed_assignment_state::IsSet,
     St::Id: redeemed_assignment_state::IsSet,
     St::PlanId: redeemed_assignment_state::IsSet,
-    St::Status: redeemed_assignment_state::IsSet,
+    St::ActivatedAt: redeemed_assignment_state::IsSet,
+    St::ExpiresAt: redeemed_assignment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RedeemedAssignment<S> {
diff --git a/crates/jacquard-api/src/app_chronosky/schedule/list_posts.rs b/crates/jacquard-api/src/app_chronosky/schedule/list_posts.rs
index fc3cdc2a..5664e60c 100644
--- a/crates/jacquard-api/src/app_chronosky/schedule/list_posts.rs
+++ b/crates/jacquard-api/src/app_chronosky/schedule/list_posts.rs
@@ -1296,66 +1296,66 @@ pub mod pagination_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Limit;
-        type Total;
         type Page;
         type TotalPages;
+        type Total;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Limit = Unset;
-        type Total = Unset;
         type Page = Unset;
         type TotalPages = Unset;
+        type Total = Unset;
     }
     ///State transition - sets the `limit` field to Set
     pub struct SetLimit<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLimit<St> {}
     impl<St: State> State for SetLimit<St> {
         type Limit = Set<members::limit>;
-        type Total = St::Total;
-        type Page = St::Page;
-        type TotalPages = St::TotalPages;
-    }
-    ///State transition - sets the `total` field to Set
-    pub struct SetTotal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotal<St> {}
-    impl<St: State> State for SetTotal<St> {
-        type Limit = St::Limit;
-        type Total = Set<members::total>;
         type Page = St::Page;
         type TotalPages = St::TotalPages;
+        type Total = St::Total;
     }
     ///State transition - sets the `page` field to Set
     pub struct SetPage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPage<St> {}
     impl<St: State> State for SetPage<St> {
         type Limit = St::Limit;
-        type Total = St::Total;
         type Page = Set<members::page>;
         type TotalPages = St::TotalPages;
+        type Total = St::Total;
     }
     ///State transition - sets the `total_pages` field to Set
     pub struct SetTotalPages<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotalPages<St> {}
     impl<St: State> State for SetTotalPages<St> {
         type Limit = St::Limit;
-        type Total = St::Total;
         type Page = St::Page;
         type TotalPages = Set<members::total_pages>;
+        type Total = St::Total;
+    }
+    ///State transition - sets the `total` field to Set
+    pub struct SetTotal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotal<St> {}
+    impl<St: State> State for SetTotal<St> {
+        type Limit = St::Limit;
+        type Page = St::Page;
+        type TotalPages = St::TotalPages;
+        type Total = Set<members::total>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `limit` field
         pub struct limit(());
-        ///Marker type for the `total` field
-        pub struct total(());
         ///Marker type for the `page` field
         pub struct page(());
         ///Marker type for the `total_pages` field
         pub struct total_pages(());
+        ///Marker type for the `total` field
+        pub struct total(());
     }
 }
 
@@ -1464,9 +1464,9 @@ impl<S: BosStr, St> PaginationBuilder<S, St>
 where
     St: pagination_state::State,
     St::Limit: pagination_state::IsSet,
-    St::Total: pagination_state::IsSet,
     St::Page: pagination_state::IsSet,
     St::TotalPages: pagination_state::IsSet,
+    St::Total: pagination_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Pagination<S> {
@@ -1503,177 +1503,177 @@ pub mod scheduled_post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type UserId;
-        type Text;
-        type ScheduledAt;
         type Id;
-        type CreatedAt;
+        type Text;
+        type UserId;
         type UpdatedAt;
-        type Status;
-        type RetryCount;
         type Langs;
+        type RetryCount;
+        type CreatedAt;
+        type Status;
+        type ScheduledAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type UserId = Unset;
-        type Text = Unset;
-        type ScheduledAt = Unset;
         type Id = Unset;
-        type CreatedAt = Unset;
+        type Text = Unset;
+        type UserId = Unset;
         type UpdatedAt = Unset;
-        type Status = Unset;
-        type RetryCount = Unset;
         type Langs = Unset;
+        type RetryCount = Unset;
+        type CreatedAt = Unset;
+        type Status = Unset;
+        type ScheduledAt = Unset;
     }
-    ///State transition - sets the `user_id` field to Set
-    pub struct SetUserId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserId<St> {}
-    impl<St: State> State for SetUserId<St> {
-        type UserId = Set<members::user_id>;
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
         type Text = St::Text;
-        type ScheduledAt = St::ScheduledAt;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type UserId = St::UserId;
         type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
         type Langs = St::Langs;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type ScheduledAt = St::ScheduledAt;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
-        type UserId = St::UserId;
-        type Text = Set<members::text>;
-        type ScheduledAt = St::ScheduledAt;
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
-        type Langs = St::Langs;
-    }
-    ///State transition - sets the `scheduled_at` field to Set
-    pub struct SetScheduledAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScheduledAt<St> {}
-    impl<St: State> State for SetScheduledAt<St> {
+        type Text = Set<members::text>;
         type UserId = St::UserId;
-        type Text = St::Text;
-        type ScheduledAt = Set<members::scheduled_at>;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
         type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
         type Langs = St::Langs;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type UserId = St::UserId;
-        type Text = St::Text;
-        type ScheduledAt = St::ScheduledAt;
-        type Id = Set<members::id>;
+        type RetryCount = St::RetryCount;
         type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
         type Status = St::Status;
-        type RetryCount = St::RetryCount;
-        type Langs = St::Langs;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type UserId = St::UserId;
-        type Text = St::Text;
         type ScheduledAt = St::ScheduledAt;
+    }
+    ///State transition - sets the `user_id` field to Set
+    pub struct SetUserId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserId<St> {}
+    impl<St: State> State for SetUserId<St> {
         type Id = St::Id;
-        type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+        type UserId = Set<members::user_id>;
         type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
         type Langs = St::Langs;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type ScheduledAt = St::ScheduledAt;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
-        type UserId = St::UserId;
-        type Text = St::Text;
-        type ScheduledAt = St::ScheduledAt;
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+        type UserId = St::UserId;
         type UpdatedAt = Set<members::updated_at>;
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
         type Langs = St::Langs;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type UserId = St::UserId;
-        type Text = St::Text;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
         type ScheduledAt = St::ScheduledAt;
+    }
+    ///State transition - sets the `langs` field to Set
+    pub struct SetLangs<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLangs<St> {}
+    impl<St: State> State for SetLangs<St> {
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+        type UserId = St::UserId;
         type UpdatedAt = St::UpdatedAt;
-        type Status = Set<members::status>;
+        type Langs = Set<members::langs>;
         type RetryCount = St::RetryCount;
-        type Langs = St::Langs;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type ScheduledAt = St::ScheduledAt;
     }
     ///State transition - sets the `retry_count` field to Set
     pub struct SetRetryCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRetryCount<St> {}
     impl<St: State> State for SetRetryCount<St> {
-        type UserId = St::UserId;
+        type Id = St::Id;
         type Text = St::Text;
+        type UserId = St::UserId;
+        type UpdatedAt = St::UpdatedAt;
+        type Langs = St::Langs;
+        type RetryCount = Set<members::retry_count>;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
         type ScheduledAt = St::ScheduledAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+        type UserId = St::UserId;
         type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
-        type RetryCount = Set<members::retry_count>;
         type Langs = St::Langs;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = Set<members::created_at>;
+        type Status = St::Status;
+        type ScheduledAt = St::ScheduledAt;
     }
-    ///State transition - sets the `langs` field to Set
-    pub struct SetLangs<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLangs<St> {}
-    impl<St: State> State for SetLangs<St> {
-        type UserId = St::UserId;
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Id = St::Id;
         type Text = St::Text;
+        type UserId = St::UserId;
+        type UpdatedAt = St::UpdatedAt;
+        type Langs = St::Langs;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = St::CreatedAt;
+        type Status = Set<members::status>;
         type ScheduledAt = St::ScheduledAt;
+    }
+    ///State transition - sets the `scheduled_at` field to Set
+    pub struct SetScheduledAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScheduledAt<St> {}
+    impl<St: State> State for SetScheduledAt<St> {
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+        type UserId = St::UserId;
         type UpdatedAt = St::UpdatedAt;
-        type Status = St::Status;
+        type Langs = St::Langs;
         type RetryCount = St::RetryCount;
-        type Langs = Set<members::langs>;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type ScheduledAt = Set<members::scheduled_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `user_id` field
-        pub struct user_id(());
-        ///Marker type for the `text` field
-        pub struct text(());
-        ///Marker type for the `scheduled_at` field
-        pub struct scheduled_at(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
+        ///Marker type for the `user_id` field
+        pub struct user_id(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
-        ///Marker type for the `status` field
-        pub struct status(());
-        ///Marker type for the `retry_count` field
-        pub struct retry_count(());
         ///Marker type for the `langs` field
         pub struct langs(());
+        ///Marker type for the `retry_count` field
+        pub struct retry_count(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
+        ///Marker type for the `scheduled_at` field
+        pub struct scheduled_at(());
     }
 }
 
@@ -2163,15 +2163,15 @@ where
 impl<S: BosStr, St> ScheduledPostBuilder<S, St>
 where
     St: scheduled_post_state::State,
-    St::UserId: scheduled_post_state::IsSet,
-    St::Text: scheduled_post_state::IsSet,
-    St::ScheduledAt: scheduled_post_state::IsSet,
     St::Id: scheduled_post_state::IsSet,
-    St::CreatedAt: scheduled_post_state::IsSet,
+    St::Text: scheduled_post_state::IsSet,
+    St::UserId: scheduled_post_state::IsSet,
     St::UpdatedAt: scheduled_post_state::IsSet,
-    St::Status: scheduled_post_state::IsSet,
-    St::RetryCount: scheduled_post_state::IsSet,
     St::Langs: scheduled_post_state::IsSet,
+    St::RetryCount: scheduled_post_state::IsSet,
+    St::CreatedAt: scheduled_post_state::IsSet,
+    St::Status: scheduled_post_state::IsSet,
+    St::ScheduledAt: scheduled_post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ScheduledPost<S> {
diff --git a/crates/jacquard-api/src/app_dropanchor/checkin.rs b/crates/jacquard-api/src/app_dropanchor/checkin.rs
index 5232655b..be5699b7 100644
--- a/crates/jacquard-api/src/app_dropanchor/checkin.rs
+++ b/crates/jacquard-api/src/app_dropanchor/checkin.rs
@@ -1080,65 +1080,65 @@ pub mod checkin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
         type CreatedAt;
         type Address;
+        type Text;
         type Geo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
         type CreatedAt = Unset;
         type Address = Unset;
+        type Text = Unset;
         type Geo = Unset;
     }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
-        type CreatedAt = St::CreatedAt;
-        type Address = St::Address;
-        type Geo = St::Geo;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
         type Address = St::Address;
+        type Text = St::Text;
         type Geo = St::Geo;
     }
     ///State transition - sets the `address` field to Set
     pub struct SetAddress<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAddress<St> {}
     impl<St: State> State for SetAddress<St> {
-        type Text = St::Text;
         type CreatedAt = St::CreatedAt;
         type Address = Set<members::address>;
+        type Text = St::Text;
+        type Geo = St::Geo;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type CreatedAt = St::CreatedAt;
+        type Address = St::Address;
+        type Text = Set<members::text>;
         type Geo = St::Geo;
     }
     ///State transition - sets the `geo` field to Set
     pub struct SetGeo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGeo<St> {}
     impl<St: State> State for SetGeo<St> {
-        type Text = St::Text;
         type CreatedAt = St::CreatedAt;
         type Address = St::Address;
+        type Text = St::Text;
         type Geo = Set<members::geo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `address` field
         pub struct address(());
+        ///Marker type for the `text` field
+        pub struct text(());
         ///Marker type for the `geo` field
         pub struct geo(());
     }
@@ -1323,9 +1323,9 @@ where
 impl<S: BosStr, St> CheckinBuilder<S, St>
 where
     St: checkin_state::State,
-    St::Text: checkin_state::IsSet,
     St::CreatedAt: checkin_state::IsSet,
     St::Address: checkin_state::IsSet,
+    St::Text: checkin_state::IsSet,
     St::Geo: checkin_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_dropanchor/comment.rs b/crates/jacquard-api/src/app_dropanchor/comment.rs
index 1433945e..6ad3444a 100644
--- a/crates/jacquard-api/src/app_dropanchor/comment.rs
+++ b/crates/jacquard-api/src/app_dropanchor/comment.rs
@@ -156,51 +156,51 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CheckinRef;
-        type CreatedAt;
         type Text;
+        type CreatedAt;
+        type CheckinRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CheckinRef = Unset;
-        type CreatedAt = Unset;
         type Text = Unset;
+        type CreatedAt = Unset;
+        type CheckinRef = Unset;
     }
-    ///State transition - sets the `checkin_ref` field to Set
-    pub struct SetCheckinRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCheckinRef<St> {}
-    impl<St: State> State for SetCheckinRef<St> {
-        type CheckinRef = Set<members::checkin_ref>;
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
-        type Text = St::Text;
+        type CheckinRef = St::CheckinRef;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type CheckinRef = St::CheckinRef;
-        type CreatedAt = Set<members::created_at>;
         type Text = St::Text;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
+        type CreatedAt = Set<members::created_at>;
         type CheckinRef = St::CheckinRef;
+    }
+    ///State transition - sets the `checkin_ref` field to Set
+    pub struct SetCheckinRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCheckinRef<St> {}
+    impl<St: State> State for SetCheckinRef<St> {
+        type Text = St::Text;
         type CreatedAt = St::CreatedAt;
-        type Text = Set<members::text>;
+        type CheckinRef = Set<members::checkin_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `checkin_ref` field
-        pub struct checkin_ref(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `text` field
         pub struct text(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `checkin_ref` field
+        pub struct checkin_ref(());
     }
 }
 
@@ -289,9 +289,9 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::CheckinRef: comment_state::IsSet,
-    St::CreatedAt: comment_state::IsSet,
     St::Text: comment_state::IsSet,
+    St::CreatedAt: comment_state::IsSet,
+    St::CheckinRef: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
@@ -434,37 +434,37 @@ pub mod strong_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
+        type Cid = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -534,8 +534,8 @@ where
 impl<S: BosStr, St> StrongRefBuilder<S, St>
 where
     St: strong_ref_state::State,
-    St::Cid: strong_ref_state::IsSet,
     St::Uri: strong_ref_state::IsSet,
+    St::Cid: strong_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> StrongRef<S> {
diff --git a/crates/jacquard-api/src/app_dropanchor/like.rs b/crates/jacquard-api/src/app_dropanchor/like.rs
index 3a00d849..b191d534 100644
--- a/crates/jacquard-api/src/app_dropanchor/like.rs
+++ b/crates/jacquard-api/src/app_dropanchor/like.rs
@@ -143,37 +143,37 @@ pub mod like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CheckinRef;
         type CreatedAt;
+        type CheckinRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CheckinRef = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `checkin_ref` field to Set
-    pub struct SetCheckinRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCheckinRef<St> {}
-    impl<St: State> State for SetCheckinRef<St> {
-        type CheckinRef = Set<members::checkin_ref>;
-        type CreatedAt = St::CreatedAt;
+        type CheckinRef = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type CheckinRef = St::CheckinRef;
         type CreatedAt = Set<members::created_at>;
+        type CheckinRef = St::CheckinRef;
+    }
+    ///State transition - sets the `checkin_ref` field to Set
+    pub struct SetCheckinRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCheckinRef<St> {}
+    impl<St: State> State for SetCheckinRef<St> {
+        type CreatedAt = St::CreatedAt;
+        type CheckinRef = Set<members::checkin_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `checkin_ref` field
-        pub struct checkin_ref(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `checkin_ref` field
+        pub struct checkin_ref(());
     }
 }
 
@@ -243,8 +243,8 @@ where
 impl<S: BosStr, St> LikeBuilder<S, St>
 where
     St: like_state::State,
-    St::CheckinRef: like_state::IsSet,
     St::CreatedAt: like_state::IsSet,
+    St::CheckinRef: like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Like<S> {
diff --git a/crates/jacquard-api/src/app_fitsky/bluesky_post.rs b/crates/jacquard-api/src/app_fitsky/bluesky_post.rs
index 21541d31..9ffc30f4 100644
--- a/crates/jacquard-api/src/app_fitsky/bluesky_post.rs
+++ b/crates/jacquard-api/src/app_fitsky/bluesky_post.rs
@@ -113,49 +113,49 @@ pub mod bluesky_post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type PostUri;
         type CreatedAt;
+        type PostUri;
         type WorkoutUri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type PostUri = Unset;
         type CreatedAt = Unset;
+        type PostUri = Unset;
         type WorkoutUri = Unset;
     }
-    ///State transition - sets the `post_uri` field to Set
-    pub struct SetPostUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPostUri<St> {}
-    impl<St: State> State for SetPostUri<St> {
-        type PostUri = Set<members::post_uri>;
-        type CreatedAt = St::CreatedAt;
-        type WorkoutUri = St::WorkoutUri;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type PostUri = St::PostUri;
         type CreatedAt = Set<members::created_at>;
+        type PostUri = St::PostUri;
+        type WorkoutUri = St::WorkoutUri;
+    }
+    ///State transition - sets the `post_uri` field to Set
+    pub struct SetPostUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPostUri<St> {}
+    impl<St: State> State for SetPostUri<St> {
+        type CreatedAt = St::CreatedAt;
+        type PostUri = Set<members::post_uri>;
         type WorkoutUri = St::WorkoutUri;
     }
     ///State transition - sets the `workout_uri` field to Set
     pub struct SetWorkoutUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorkoutUri<St> {}
     impl<St: State> State for SetWorkoutUri<St> {
-        type PostUri = St::PostUri;
         type CreatedAt = St::CreatedAt;
+        type PostUri = St::PostUri;
         type WorkoutUri = Set<members::workout_uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `post_uri` field
-        pub struct post_uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `post_uri` field
+        pub struct post_uri(());
         ///Marker type for the `workout_uri` field
         pub struct workout_uri(());
     }
@@ -246,8 +246,8 @@ where
 impl<S: BosStr, St> BlueskyPostBuilder<S, St>
 where
     St: bluesky_post_state::State,
-    St::PostUri: bluesky_post_state::IsSet,
     St::CreatedAt: bluesky_post_state::IsSet,
+    St::PostUri: bluesky_post_state::IsSet,
     St::WorkoutUri: bluesky_post_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_fitsky/goal.rs b/crates/jacquard-api/src/app_fitsky/goal.rs
index af4395f8..2177b638 100644
--- a/crates/jacquard-api/src/app_fitsky/goal.rs
+++ b/crates/jacquard-api/src/app_fitsky/goal.rs
@@ -318,85 +318,85 @@ pub mod goal_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type TargetValue;
         type CreatedAt;
+        type StartDate;
         type Metric;
         type Period;
-        type StartDate;
-        type TargetValue;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type TargetValue = Unset;
         type CreatedAt = Unset;
+        type StartDate = Unset;
         type Metric = Unset;
         type Period = Unset;
-        type StartDate = Unset;
-        type TargetValue = Unset;
+    }
+    ///State transition - sets the `target_value` field to Set
+    pub struct SetTargetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTargetValue<St> {}
+    impl<St: State> State for SetTargetValue<St> {
+        type TargetValue = Set<members::target_value>;
+        type CreatedAt = St::CreatedAt;
+        type StartDate = St::StartDate;
+        type Metric = St::Metric;
+        type Period = St::Period;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type TargetValue = St::TargetValue;
         type CreatedAt = Set<members::created_at>;
+        type StartDate = St::StartDate;
         type Metric = St::Metric;
         type Period = St::Period;
-        type StartDate = St::StartDate;
+    }
+    ///State transition - sets the `start_date` field to Set
+    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartDate<St> {}
+    impl<St: State> State for SetStartDate<St> {
         type TargetValue = St::TargetValue;
+        type CreatedAt = St::CreatedAt;
+        type StartDate = Set<members::start_date>;
+        type Metric = St::Metric;
+        type Period = St::Period;
     }
     ///State transition - sets the `metric` field to Set
     pub struct SetMetric<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMetric<St> {}
     impl<St: State> State for SetMetric<St> {
+        type TargetValue = St::TargetValue;
         type CreatedAt = St::CreatedAt;
+        type StartDate = St::StartDate;
         type Metric = Set<members::metric>;
         type Period = St::Period;
-        type StartDate = St::StartDate;
-        type TargetValue = St::TargetValue;
     }
     ///State transition - sets the `period` field to Set
     pub struct SetPeriod<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPeriod<St> {}
     impl<St: State> State for SetPeriod<St> {
-        type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
-        type Period = Set<members::period>;
-        type StartDate = St::StartDate;
-        type TargetValue = St::TargetValue;
-    }
-    ///State transition - sets the `start_date` field to Set
-    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartDate<St> {}
-    impl<St: State> State for SetStartDate<St> {
-        type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
-        type Period = St::Period;
-        type StartDate = Set<members::start_date>;
         type TargetValue = St::TargetValue;
-    }
-    ///State transition - sets the `target_value` field to Set
-    pub struct SetTargetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTargetValue<St> {}
-    impl<St: State> State for SetTargetValue<St> {
         type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
-        type Period = St::Period;
         type StartDate = St::StartDate;
-        type TargetValue = Set<members::target_value>;
+        type Metric = St::Metric;
+        type Period = Set<members::period>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `target_value` field
+        pub struct target_value(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `start_date` field
+        pub struct start_date(());
         ///Marker type for the `metric` field
         pub struct metric(());
         ///Marker type for the `period` field
         pub struct period(());
-        ///Marker type for the `start_date` field
-        pub struct start_date(());
-        ///Marker type for the `target_value` field
-        pub struct target_value(());
     }
 }
 
@@ -543,11 +543,11 @@ where
 impl<S: BosStr, St> GoalBuilder<S, St>
 where
     St: goal_state::State,
+    St::TargetValue: goal_state::IsSet,
     St::CreatedAt: goal_state::IsSet,
+    St::StartDate: goal_state::IsSet,
     St::Metric: goal_state::IsSet,
     St::Period: goal_state::IsSet,
-    St::StartDate: goal_state::IsSet,
-    St::TargetValue: goal_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Goal<S> {
diff --git a/crates/jacquard-api/src/app_fitsky/trend.rs b/crates/jacquard-api/src/app_fitsky/trend.rs
index dc483b6a..63310011 100644
--- a/crates/jacquard-api/src/app_fitsky/trend.rs
+++ b/crates/jacquard-api/src/app_fitsky/trend.rs
@@ -948,84 +948,84 @@ pub mod trend_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type WidgetType;
-        type CreatedAt;
-        type Metric;
         type Period;
         type Summary;
+        type CreatedAt;
+        type Metric;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type WidgetType = Unset;
-        type CreatedAt = Unset;
-        type Metric = Unset;
         type Period = Unset;
         type Summary = Unset;
+        type CreatedAt = Unset;
+        type Metric = Unset;
     }
     ///State transition - sets the `widget_type` field to Set
     pub struct SetWidgetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidgetType<St> {}
     impl<St: State> State for SetWidgetType<St> {
         type WidgetType = Set<members::widget_type>;
-        type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
-        type Period = St::Period;
-        type Summary = St::Summary;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type WidgetType = St::WidgetType;
-        type CreatedAt = Set<members::created_at>;
-        type Metric = St::Metric;
         type Period = St::Period;
         type Summary = St::Summary;
-    }
-    ///State transition - sets the `metric` field to Set
-    pub struct SetMetric<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMetric<St> {}
-    impl<St: State> State for SetMetric<St> {
-        type WidgetType = St::WidgetType;
         type CreatedAt = St::CreatedAt;
-        type Metric = Set<members::metric>;
-        type Period = St::Period;
-        type Summary = St::Summary;
+        type Metric = St::Metric;
     }
     ///State transition - sets the `period` field to Set
     pub struct SetPeriod<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPeriod<St> {}
     impl<St: State> State for SetPeriod<St> {
         type WidgetType = St::WidgetType;
-        type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
         type Period = Set<members::period>;
         type Summary = St::Summary;
+        type CreatedAt = St::CreatedAt;
+        type Metric = St::Metric;
     }
     ///State transition - sets the `summary` field to Set
     pub struct SetSummary<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSummary<St> {}
     impl<St: State> State for SetSummary<St> {
         type WidgetType = St::WidgetType;
+        type Period = St::Period;
+        type Summary = Set<members::summary>;
         type CreatedAt = St::CreatedAt;
         type Metric = St::Metric;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type WidgetType = St::WidgetType;
         type Period = St::Period;
-        type Summary = Set<members::summary>;
+        type Summary = St::Summary;
+        type CreatedAt = Set<members::created_at>;
+        type Metric = St::Metric;
+    }
+    ///State transition - sets the `metric` field to Set
+    pub struct SetMetric<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMetric<St> {}
+    impl<St: State> State for SetMetric<St> {
+        type WidgetType = St::WidgetType;
+        type Period = St::Period;
+        type Summary = St::Summary;
+        type CreatedAt = St::CreatedAt;
+        type Metric = Set<members::metric>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `widget_type` field
         pub struct widget_type(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `metric` field
-        pub struct metric(());
         ///Marker type for the `period` field
         pub struct period(());
         ///Marker type for the `summary` field
         pub struct summary(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `metric` field
+        pub struct metric(());
     }
 }
 
@@ -1218,10 +1218,10 @@ impl<S: BosStr, St> TrendBuilder<S, St>
 where
     St: trend_state::State,
     St::WidgetType: trend_state::IsSet,
-    St::CreatedAt: trend_state::IsSet,
-    St::Metric: trend_state::IsSet,
     St::Period: trend_state::IsSet,
     St::Summary: trend_state::IsSet,
+    St::CreatedAt: trend_state::IsSet,
+    St::Metric: trend_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Trend<S> {
diff --git a/crates/jacquard-api/src/app_fitsky/workout.rs b/crates/jacquard-api/src/app_fitsky/workout.rs
index 989bfd3c..f0fb9652 100644
--- a/crates/jacquard-api/src/app_fitsky/workout.rs
+++ b/crates/jacquard-api/src/app_fitsky/workout.rs
@@ -2518,37 +2518,37 @@ pub mod exercise_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Sets;
         type Name;
+        type Sets;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Sets = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `sets` field to Set
-    pub struct SetSets<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSets<St> {}
-    impl<St: State> State for SetSets<St> {
-        type Sets = Set<members::sets>;
-        type Name = St::Name;
+        type Sets = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Sets = St::Sets;
         type Name = Set<members::name>;
+        type Sets = St::Sets;
+    }
+    ///State transition - sets the `sets` field to Set
+    pub struct SetSets<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSets<St> {}
+    impl<St: State> State for SetSets<St> {
+        type Name = St::Name;
+        type Sets = Set<members::sets>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `sets` field
-        pub struct sets(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `sets` field
+        pub struct sets(());
     }
 }
 
@@ -2618,8 +2618,8 @@ where
 impl<S: BosStr, St> ExerciseBuilder<S, St>
 where
     St: exercise_state::State,
-    St::Sets: exercise_state::IsSet,
     St::Name: exercise_state::IsSet,
+    St::Sets: exercise_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Exercise<S> {
@@ -2649,37 +2649,37 @@ pub mod heart_rate_sample_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Timestamp;
         type Bpm;
+        type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Timestamp = Unset;
         type Bpm = Unset;
-    }
-    ///State transition - sets the `timestamp` field to Set
-    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
-    impl<St: State> State for SetTimestamp<St> {
-        type Timestamp = Set<members::timestamp>;
-        type Bpm = St::Bpm;
+        type Timestamp = Unset;
     }
     ///State transition - sets the `bpm` field to Set
     pub struct SetBpm<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBpm<St> {}
     impl<St: State> State for SetBpm<St> {
-        type Timestamp = St::Timestamp;
         type Bpm = Set<members::bpm>;
+        type Timestamp = St::Timestamp;
+    }
+    ///State transition - sets the `timestamp` field to Set
+    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
+    impl<St: State> State for SetTimestamp<St> {
+        type Bpm = St::Bpm;
+        type Timestamp = Set<members::timestamp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `timestamp` field
-        pub struct timestamp(());
         ///Marker type for the `bpm` field
         pub struct bpm(());
+        ///Marker type for the `timestamp` field
+        pub struct timestamp(());
     }
 }
 
@@ -2749,8 +2749,8 @@ where
 impl<S: BosStr, St> HeartRateSampleBuilder<S, St>
 where
     St: heart_rate_sample_state::State,
-    St::Timestamp: heart_rate_sample_state::IsSet,
     St::Bpm: heart_rate_sample_state::IsSet,
+    St::Timestamp: heart_rate_sample_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> HeartRateSample<S> {
@@ -2783,85 +2783,85 @@ pub mod workout_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Duration;
+        type Title;
+        type Type;
         type StartedAt;
         type CreatedAt;
-        type Type;
-        type Title;
-        type Duration;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Duration = Unset;
+        type Title = Unset;
+        type Type = Unset;
         type StartedAt = Unset;
         type CreatedAt = Unset;
-        type Type = Unset;
-        type Title = Unset;
-        type Duration = Unset;
     }
-    ///State transition - sets the `started_at` field to Set
-    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
-    impl<St: State> State for SetStartedAt<St> {
-        type StartedAt = Set<members::started_at>;
-        type CreatedAt = St::CreatedAt;
-        type Type = St::Type;
+    ///State transition - sets the `duration` field to Set
+    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDuration<St> {}
+    impl<St: State> State for SetDuration<St> {
+        type Duration = Set<members::duration>;
         type Title = St::Title;
-        type Duration = St::Duration;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type StartedAt = St::StartedAt;
-        type CreatedAt = Set<members::created_at>;
         type Type = St::Type;
-        type Title = St::Title;
-        type Duration = St::Duration;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
         type StartedAt = St::StartedAt;
         type CreatedAt = St::CreatedAt;
-        type Type = Set<members::r#type>;
-        type Title = St::Title;
-        type Duration = St::Duration;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
+        type Duration = St::Duration;
+        type Title = Set<members::title>;
+        type Type = St::Type;
         type StartedAt = St::StartedAt;
         type CreatedAt = St::CreatedAt;
-        type Type = St::Type;
-        type Title = Set<members::title>;
-        type Duration = St::Duration;
     }
-    ///State transition - sets the `duration` field to Set
-    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDuration<St> {}
-    impl<St: State> State for SetDuration<St> {
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Duration = St::Duration;
+        type Title = St::Title;
+        type Type = Set<members::r#type>;
         type StartedAt = St::StartedAt;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `started_at` field to Set
+    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
+    impl<St: State> State for SetStartedAt<St> {
+        type Duration = St::Duration;
+        type Title = St::Title;
         type Type = St::Type;
+        type StartedAt = Set<members::started_at>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Duration = St::Duration;
         type Title = St::Title;
-        type Duration = Set<members::duration>;
+        type Type = St::Type;
+        type StartedAt = St::StartedAt;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `duration` field
+        pub struct duration(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
         ///Marker type for the `started_at` field
         pub struct started_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `duration` field
-        pub struct duration(());
     }
 }
 
@@ -3132,11 +3132,11 @@ impl<S: BosStr, St: workout_state::State> WorkoutBuilder<S, St> {
 impl<S: BosStr, St> WorkoutBuilder<S, St>
 where
     St: workout_state::State,
+    St::Duration: workout_state::IsSet,
+    St::Title: workout_state::IsSet,
+    St::Type: workout_state::IsSet,
     St::StartedAt: workout_state::IsSet,
     St::CreatedAt: workout_state::IsSet,
-    St::Type: workout_state::IsSet,
-    St::Title: workout_state::IsSet,
-    St::Duration: workout_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Workout<S> {
@@ -3352,51 +3352,51 @@ pub mod route_point_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Timestamp;
         type LatE6;
         type LngE6;
+        type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Timestamp = Unset;
         type LatE6 = Unset;
         type LngE6 = Unset;
-    }
-    ///State transition - sets the `timestamp` field to Set
-    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
-    impl<St: State> State for SetTimestamp<St> {
-        type Timestamp = Set<members::timestamp>;
-        type LatE6 = St::LatE6;
-        type LngE6 = St::LngE6;
+        type Timestamp = Unset;
     }
     ///State transition - sets the `lat_e6` field to Set
     pub struct SetLatE6<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLatE6<St> {}
     impl<St: State> State for SetLatE6<St> {
-        type Timestamp = St::Timestamp;
         type LatE6 = Set<members::lat_e6>;
         type LngE6 = St::LngE6;
+        type Timestamp = St::Timestamp;
     }
     ///State transition - sets the `lng_e6` field to Set
     pub struct SetLngE6<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLngE6<St> {}
     impl<St: State> State for SetLngE6<St> {
-        type Timestamp = St::Timestamp;
         type LatE6 = St::LatE6;
         type LngE6 = Set<members::lng_e6>;
+        type Timestamp = St::Timestamp;
+    }
+    ///State transition - sets the `timestamp` field to Set
+    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
+    impl<St: State> State for SetTimestamp<St> {
+        type LatE6 = St::LatE6;
+        type LngE6 = St::LngE6;
+        type Timestamp = Set<members::timestamp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `timestamp` field
-        pub struct timestamp(());
         ///Marker type for the `lat_e6` field
         pub struct lat_e6(());
         ///Marker type for the `lng_e6` field
         pub struct lng_e6(());
+        ///Marker type for the `timestamp` field
+        pub struct timestamp(());
     }
 }
 
@@ -3485,9 +3485,9 @@ where
 impl<S: BosStr, St> RoutePointBuilder<S, St>
 where
     St: route_point_state::State,
-    St::Timestamp: route_point_state::IsSet,
     St::LatE6: route_point_state::IsSet,
     St::LngE6: route_point_state::IsSet,
+    St::Timestamp: route_point_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RoutePoint<S> {
diff --git a/crates/jacquard-api/src/app_fitsky/workout_plan.rs b/crates/jacquard-api/src/app_fitsky/workout_plan.rs
index a65ead28..8a229ad6 100644
--- a/crates/jacquard-api/src/app_fitsky/workout_plan.rs
+++ b/crates/jacquard-api/src/app_fitsky/workout_plan.rs
@@ -337,67 +337,67 @@ pub mod workout_plan_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type Type;
         type Exercises;
         type CreatedAt;
+        type Type;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type Type = Unset;
         type Exercises = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Type = St::Type;
-        type Exercises = St::Exercises;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Name = St::Name;
-        type Type = Set<members::r#type>;
-        type Exercises = St::Exercises;
-        type CreatedAt = St::CreatedAt;
+        type Type = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `exercises` field to Set
     pub struct SetExercises<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetExercises<St> {}
     impl<St: State> State for SetExercises<St> {
-        type Name = St::Name;
-        type Type = St::Type;
         type Exercises = Set<members::exercises>;
         type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
+        type Name = St::Name;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
-        type Type = St::Type;
         type Exercises = St::Exercises;
         type CreatedAt = Set<members::created_at>;
+        type Type = St::Type;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Exercises = St::Exercises;
+        type CreatedAt = St::CreatedAt;
+        type Type = Set<members::r#type>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Exercises = St::Exercises;
+        type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `exercises` field
         pub struct exercises(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -524,10 +524,10 @@ where
 impl<S: BosStr, St> WorkoutPlanBuilder<S, St>
 where
     St: workout_plan_state::State,
-    St::Name: workout_plan_state::IsSet,
-    St::Type: workout_plan_state::IsSet,
     St::Exercises: workout_plan_state::IsSet,
     St::CreatedAt: workout_plan_state::IsSet,
+    St::Type: workout_plan_state::IsSet,
+    St::Name: workout_plan_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WorkoutPlan<S> {
@@ -688,51 +688,51 @@ pub mod plan_exercise_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TargetSets;
         type Name;
         type TargetReps;
+        type TargetSets;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TargetSets = Unset;
         type Name = Unset;
         type TargetReps = Unset;
-    }
-    ///State transition - sets the `target_sets` field to Set
-    pub struct SetTargetSets<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTargetSets<St> {}
-    impl<St: State> State for SetTargetSets<St> {
-        type TargetSets = Set<members::target_sets>;
-        type Name = St::Name;
-        type TargetReps = St::TargetReps;
+        type TargetSets = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type TargetSets = St::TargetSets;
         type Name = Set<members::name>;
         type TargetReps = St::TargetReps;
+        type TargetSets = St::TargetSets;
     }
     ///State transition - sets the `target_reps` field to Set
     pub struct SetTargetReps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTargetReps<St> {}
     impl<St: State> State for SetTargetReps<St> {
-        type TargetSets = St::TargetSets;
         type Name = St::Name;
         type TargetReps = Set<members::target_reps>;
+        type TargetSets = St::TargetSets;
+    }
+    ///State transition - sets the `target_sets` field to Set
+    pub struct SetTargetSets<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTargetSets<St> {}
+    impl<St: State> State for SetTargetSets<St> {
+        type Name = St::Name;
+        type TargetReps = St::TargetReps;
+        type TargetSets = Set<members::target_sets>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `target_sets` field
-        pub struct target_sets(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `target_reps` field
         pub struct target_reps(());
+        ///Marker type for the `target_sets` field
+        pub struct target_sets(());
     }
 }
 
@@ -834,9 +834,9 @@ where
 impl<S: BosStr, St> PlanExerciseBuilder<S, St>
 where
     St: plan_exercise_state::State,
-    St::TargetSets: plan_exercise_state::IsSet,
     St::Name: plan_exercise_state::IsSet,
     St::TargetReps: plan_exercise_state::IsSet,
+    St::TargetSets: plan_exercise_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlanExercise<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/dwc/event.rs b/crates/jacquard-api/src/app_gainforest/dwc/event.rs
index 8441eb93..a4717b71 100644
--- a/crates/jacquard-api/src/app_gainforest/dwc/event.rs
+++ b/crates/jacquard-api/src/app_gainforest/dwc/event.rs
@@ -471,51 +471,51 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type EventId;
         type EventDate;
         type CreatedAt;
-        type EventId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type EventId = Unset;
         type EventDate = Unset;
         type CreatedAt = Unset;
-        type EventId = Unset;
+    }
+    ///State transition - sets the `event_id` field to Set
+    pub struct SetEventId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEventId<St> {}
+    impl<St: State> State for SetEventId<St> {
+        type EventId = Set<members::event_id>;
+        type EventDate = St::EventDate;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `event_date` field to Set
     pub struct SetEventDate<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEventDate<St> {}
     impl<St: State> State for SetEventDate<St> {
+        type EventId = St::EventId;
         type EventDate = Set<members::event_date>;
         type CreatedAt = St::CreatedAt;
-        type EventId = St::EventId;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type EventDate = St::EventDate;
-        type CreatedAt = Set<members::created_at>;
         type EventId = St::EventId;
-    }
-    ///State transition - sets the `event_id` field to Set
-    pub struct SetEventId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEventId<St> {}
-    impl<St: State> State for SetEventId<St> {
         type EventDate = St::EventDate;
-        type CreatedAt = St::CreatedAt;
-        type EventId = Set<members::event_id>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `event_id` field
+        pub struct event_id(());
         ///Marker type for the `event_date` field
         pub struct event_date(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `event_id` field
-        pub struct event_id(());
     }
 }
 
@@ -975,9 +975,9 @@ impl<S: BosStr, St: event_state::State> EventBuilder<S, St> {
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
+    St::EventId: event_state::IsSet,
     St::EventDate: event_state::IsSet,
     St::CreatedAt: event_state::IsSet,
-    St::EventId: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/dwc/measurement.rs b/crates/jacquard-api/src/app_gainforest/dwc/measurement.rs
index c9258824..75dab551 100644
--- a/crates/jacquard-api/src/app_gainforest/dwc/measurement.rs
+++ b/crates/jacquard-api/src/app_gainforest/dwc/measurement.rs
@@ -264,67 +264,67 @@ pub mod measurement_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type MeasurementValue;
+        type MeasurementType;
         type CreatedAt;
         type OccurrenceRef;
-        type MeasurementType;
-        type MeasurementValue;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type MeasurementValue = Unset;
+        type MeasurementType = Unset;
         type CreatedAt = Unset;
         type OccurrenceRef = Unset;
-        type MeasurementType = Unset;
-        type MeasurementValue = Unset;
+    }
+    ///State transition - sets the `measurement_value` field to Set
+    pub struct SetMeasurementValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMeasurementValue<St> {}
+    impl<St: State> State for SetMeasurementValue<St> {
+        type MeasurementValue = Set<members::measurement_value>;
+        type MeasurementType = St::MeasurementType;
+        type CreatedAt = St::CreatedAt;
+        type OccurrenceRef = St::OccurrenceRef;
+    }
+    ///State transition - sets the `measurement_type` field to Set
+    pub struct SetMeasurementType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMeasurementType<St> {}
+    impl<St: State> State for SetMeasurementType<St> {
+        type MeasurementValue = St::MeasurementValue;
+        type MeasurementType = Set<members::measurement_type>;
+        type CreatedAt = St::CreatedAt;
+        type OccurrenceRef = St::OccurrenceRef;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type MeasurementValue = St::MeasurementValue;
+        type MeasurementType = St::MeasurementType;
         type CreatedAt = Set<members::created_at>;
         type OccurrenceRef = St::OccurrenceRef;
-        type MeasurementType = St::MeasurementType;
-        type MeasurementValue = St::MeasurementValue;
     }
     ///State transition - sets the `occurrence_ref` field to Set
     pub struct SetOccurrenceRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOccurrenceRef<St> {}
     impl<St: State> State for SetOccurrenceRef<St> {
-        type CreatedAt = St::CreatedAt;
-        type OccurrenceRef = Set<members::occurrence_ref>;
-        type MeasurementType = St::MeasurementType;
-        type MeasurementValue = St::MeasurementValue;
-    }
-    ///State transition - sets the `measurement_type` field to Set
-    pub struct SetMeasurementType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMeasurementType<St> {}
-    impl<St: State> State for SetMeasurementType<St> {
-        type CreatedAt = St::CreatedAt;
-        type OccurrenceRef = St::OccurrenceRef;
-        type MeasurementType = Set<members::measurement_type>;
         type MeasurementValue = St::MeasurementValue;
-    }
-    ///State transition - sets the `measurement_value` field to Set
-    pub struct SetMeasurementValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMeasurementValue<St> {}
-    impl<St: State> State for SetMeasurementValue<St> {
-        type CreatedAt = St::CreatedAt;
-        type OccurrenceRef = St::OccurrenceRef;
         type MeasurementType = St::MeasurementType;
-        type MeasurementValue = Set<members::measurement_value>;
+        type CreatedAt = St::CreatedAt;
+        type OccurrenceRef = Set<members::occurrence_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `measurement_value` field
+        pub struct measurement_value(());
+        ///Marker type for the `measurement_type` field
+        pub struct measurement_type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `occurrence_ref` field
         pub struct occurrence_ref(());
-        ///Marker type for the `measurement_type` field
-        pub struct measurement_type(());
-        ///Marker type for the `measurement_value` field
-        pub struct measurement_value(());
     }
 }
 
@@ -562,10 +562,10 @@ where
 impl<S: BosStr, St> MeasurementBuilder<S, St>
 where
     St: measurement_state::State,
+    St::MeasurementValue: measurement_state::IsSet,
+    St::MeasurementType: measurement_state::IsSet,
     St::CreatedAt: measurement_state::IsSet,
     St::OccurrenceRef: measurement_state::IsSet,
-    St::MeasurementType: measurement_state::IsSet,
-    St::MeasurementValue: measurement_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Measurement<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/dwc/occurrence.rs b/crates/jacquard-api/src/app_gainforest/dwc/occurrence.rs
index 58eae96f..4ff2ba00 100644
--- a/crates/jacquard-api/src/app_gainforest/dwc/occurrence.rs
+++ b/crates/jacquard-api/src/app_gainforest/dwc/occurrence.rs
@@ -1182,67 +1182,67 @@ pub mod occurrence_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type BasisOfRecord;
+        type EventDate;
         type ScientificName;
         type CreatedAt;
-        type EventDate;
+        type BasisOfRecord;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type BasisOfRecord = Unset;
+        type EventDate = Unset;
         type ScientificName = Unset;
         type CreatedAt = Unset;
-        type EventDate = Unset;
+        type BasisOfRecord = Unset;
     }
-    ///State transition - sets the `basis_of_record` field to Set
-    pub struct SetBasisOfRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBasisOfRecord<St> {}
-    impl<St: State> State for SetBasisOfRecord<St> {
-        type BasisOfRecord = Set<members::basis_of_record>;
+    ///State transition - sets the `event_date` field to Set
+    pub struct SetEventDate<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEventDate<St> {}
+    impl<St: State> State for SetEventDate<St> {
+        type EventDate = Set<members::event_date>;
         type ScientificName = St::ScientificName;
         type CreatedAt = St::CreatedAt;
-        type EventDate = St::EventDate;
+        type BasisOfRecord = St::BasisOfRecord;
     }
     ///State transition - sets the `scientific_name` field to Set
     pub struct SetScientificName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScientificName<St> {}
     impl<St: State> State for SetScientificName<St> {
-        type BasisOfRecord = St::BasisOfRecord;
+        type EventDate = St::EventDate;
         type ScientificName = Set<members::scientific_name>;
         type CreatedAt = St::CreatedAt;
-        type EventDate = St::EventDate;
+        type BasisOfRecord = St::BasisOfRecord;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type BasisOfRecord = St::BasisOfRecord;
+        type EventDate = St::EventDate;
         type ScientificName = St::ScientificName;
         type CreatedAt = Set<members::created_at>;
-        type EventDate = St::EventDate;
-    }
-    ///State transition - sets the `event_date` field to Set
-    pub struct SetEventDate<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEventDate<St> {}
-    impl<St: State> State for SetEventDate<St> {
         type BasisOfRecord = St::BasisOfRecord;
+    }
+    ///State transition - sets the `basis_of_record` field to Set
+    pub struct SetBasisOfRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBasisOfRecord<St> {}
+    impl<St: State> State for SetBasisOfRecord<St> {
+        type EventDate = St::EventDate;
         type ScientificName = St::ScientificName;
         type CreatedAt = St::CreatedAt;
-        type EventDate = Set<members::event_date>;
+        type BasisOfRecord = Set<members::basis_of_record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `basis_of_record` field
-        pub struct basis_of_record(());
+        ///Marker type for the `event_date` field
+        pub struct event_date(());
         ///Marker type for the `scientific_name` field
         pub struct scientific_name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `event_date` field
-        pub struct event_date(());
+        ///Marker type for the `basis_of_record` field
+        pub struct basis_of_record(());
     }
 }
 
@@ -2488,10 +2488,10 @@ impl<S: BosStr, St: occurrence_state::State> OccurrenceBuilder<S, St> {
 impl<S: BosStr, St> OccurrenceBuilder<S, St>
 where
     St: occurrence_state::State,
-    St::BasisOfRecord: occurrence_state::IsSet,
+    St::EventDate: occurrence_state::IsSet,
     St::ScientificName: occurrence_state::IsSet,
     St::CreatedAt: occurrence_state::IsSet,
-    St::EventDate: occurrence_state::IsSet,
+    St::BasisOfRecord: occurrence_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Occurrence<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/evaluator.rs b/crates/jacquard-api/src/app_gainforest/evaluator.rs
index bab402e7..e301c671 100644
--- a/crates/jacquard-api/src/app_gainforest/evaluator.rs
+++ b/crates/jacquard-api/src/app_gainforest/evaluator.rs
@@ -966,49 +966,49 @@ pub mod candidate_taxon_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Confidence;
         type ScientificName;
+        type Confidence;
         type Rank;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Confidence = Unset;
         type ScientificName = Unset;
+        type Confidence = Unset;
         type Rank = Unset;
     }
-    ///State transition - sets the `confidence` field to Set
-    pub struct SetConfidence<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetConfidence<St> {}
-    impl<St: State> State for SetConfidence<St> {
-        type Confidence = Set<members::confidence>;
-        type ScientificName = St::ScientificName;
-        type Rank = St::Rank;
-    }
     ///State transition - sets the `scientific_name` field to Set
     pub struct SetScientificName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScientificName<St> {}
     impl<St: State> State for SetScientificName<St> {
-        type Confidence = St::Confidence;
         type ScientificName = Set<members::scientific_name>;
+        type Confidence = St::Confidence;
+        type Rank = St::Rank;
+    }
+    ///State transition - sets the `confidence` field to Set
+    pub struct SetConfidence<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetConfidence<St> {}
+    impl<St: State> State for SetConfidence<St> {
+        type ScientificName = St::ScientificName;
+        type Confidence = Set<members::confidence>;
         type Rank = St::Rank;
     }
     ///State transition - sets the `rank` field to Set
     pub struct SetRank<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRank<St> {}
     impl<St: State> State for SetRank<St> {
-        type Confidence = St::Confidence;
         type ScientificName = St::ScientificName;
+        type Confidence = St::Confidence;
         type Rank = Set<members::rank>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `confidence` field
-        pub struct confidence(());
         ///Marker type for the `scientific_name` field
         pub struct scientific_name(());
+        ///Marker type for the `confidence` field
+        pub struct confidence(());
         ///Marker type for the `rank` field
         pub struct rank(());
     }
@@ -1159,8 +1159,8 @@ where
 impl<S: BosStr, St> CandidateTaxonBuilder<S, St>
 where
     St: candidate_taxon_state::State,
-    St::Confidence: candidate_taxon_state::IsSet,
     St::ScientificName: candidate_taxon_state::IsSet,
+    St::Confidence: candidate_taxon_state::IsSet,
     St::Rank: candidate_taxon_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_gainforest/evaluator/subscription.rs b/crates/jacquard-api/src/app_gainforest/evaluator/subscription.rs
index 71112c36..2a12ac93 100644
--- a/crates/jacquard-api/src/app_gainforest/evaluator/subscription.rs
+++ b/crates/jacquard-api/src/app_gainforest/evaluator/subscription.rs
@@ -140,37 +140,37 @@ pub mod subscription_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Evaluator;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Evaluator = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Evaluator = St::Evaluator;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `evaluator` field to Set
     pub struct SetEvaluator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvaluator<St> {}
     impl<St: State> State for SetEvaluator<St> {
-        type CreatedAt = St::CreatedAt;
         type Evaluator = Set<members::evaluator>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Evaluator = St::Evaluator;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `evaluator` field
         pub struct evaluator(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -266,8 +266,8 @@ where
 impl<S: BosStr, St> SubscriptionBuilder<S, St>
 where
     St: subscription_state::State,
-    St::CreatedAt: subscription_state::IsSet,
     St::Evaluator: subscription_state::IsSet,
+    St::CreatedAt: subscription_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Subscription<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/default_site.rs b/crates/jacquard-api/src/app_gainforest/organization/default_site.rs
index 3454d839..256cfc17 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/default_site.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/default_site.rs
@@ -114,37 +114,37 @@ pub mod default_site_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Site;
         type CreatedAt;
+        type Site;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Site = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `site` field to Set
-    pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSite<St> {}
-    impl<St: State> State for SetSite<St> {
-        type Site = Set<members::site>;
-        type CreatedAt = St::CreatedAt;
+        type Site = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Site = St::Site;
         type CreatedAt = Set<members::created_at>;
+        type Site = St::Site;
+    }
+    ///State transition - sets the `site` field to Set
+    pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSite<St> {}
+    impl<St: State> State for SetSite<St> {
+        type CreatedAt = St::CreatedAt;
+        type Site = Set<members::site>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `site` field
-        pub struct site(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `site` field
+        pub struct site(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> DefaultSiteBuilder<S, St>
 where
     St: default_site_state::State,
-    St::Site: default_site_state::IsSet,
     St::CreatedAt: default_site_state::IsSet,
+    St::Site: default_site_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DefaultSite<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/info.rs b/crates/jacquard-api/src/app_gainforest/organization/info.rs
index 2ad333a7..218d2a27 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/info.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/info.rs
@@ -202,127 +202,127 @@ pub mod info_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Visibility;
-        type CreatedAt;
-        type LongDescription;
         type Country;
+        type LongDescription;
+        type CreatedAt;
         type DisplayName;
-        type Objectives;
         type ShortDescription;
+        type Objectives;
+        type Visibility;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Visibility = Unset;
-        type CreatedAt = Unset;
-        type LongDescription = Unset;
         type Country = Unset;
+        type LongDescription = Unset;
+        type CreatedAt = Unset;
         type DisplayName = Unset;
-        type Objectives = Unset;
         type ShortDescription = Unset;
+        type Objectives = Unset;
+        type Visibility = Unset;
     }
-    ///State transition - sets the `visibility` field to Set
-    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVisibility<St> {}
-    impl<St: State> State for SetVisibility<St> {
-        type Visibility = Set<members::visibility>;
-        type CreatedAt = St::CreatedAt;
+    ///State transition - sets the `country` field to Set
+    pub struct SetCountry<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCountry<St> {}
+    impl<St: State> State for SetCountry<St> {
+        type Country = Set<members::country>;
         type LongDescription = St::LongDescription;
-        type Country = St::Country;
+        type CreatedAt = St::CreatedAt;
         type DisplayName = St::DisplayName;
-        type Objectives = St::Objectives;
         type ShortDescription = St::ShortDescription;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Visibility = St::Visibility;
-        type CreatedAt = Set<members::created_at>;
-        type LongDescription = St::LongDescription;
-        type Country = St::Country;
-        type DisplayName = St::DisplayName;
         type Objectives = St::Objectives;
-        type ShortDescription = St::ShortDescription;
+        type Visibility = St::Visibility;
     }
     ///State transition - sets the `long_description` field to Set
     pub struct SetLongDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLongDescription<St> {}
     impl<St: State> State for SetLongDescription<St> {
-        type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
-        type LongDescription = Set<members::long_description>;
         type Country = St::Country;
+        type LongDescription = Set<members::long_description>;
+        type CreatedAt = St::CreatedAt;
         type DisplayName = St::DisplayName;
-        type Objectives = St::Objectives;
         type ShortDescription = St::ShortDescription;
-    }
-    ///State transition - sets the `country` field to Set
-    pub struct SetCountry<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCountry<St> {}
-    impl<St: State> State for SetCountry<St> {
+        type Objectives = St::Objectives;
         type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Country = St::Country;
         type LongDescription = St::LongDescription;
-        type Country = Set<members::country>;
+        type CreatedAt = Set<members::created_at>;
         type DisplayName = St::DisplayName;
-        type Objectives = St::Objectives;
         type ShortDescription = St::ShortDescription;
+        type Objectives = St::Objectives;
+        type Visibility = St::Visibility;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
-        type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
-        type LongDescription = St::LongDescription;
         type Country = St::Country;
+        type LongDescription = St::LongDescription;
+        type CreatedAt = St::CreatedAt;
         type DisplayName = Set<members::display_name>;
-        type Objectives = St::Objectives;
         type ShortDescription = St::ShortDescription;
+        type Objectives = St::Objectives;
+        type Visibility = St::Visibility;
+    }
+    ///State transition - sets the `short_description` field to Set
+    pub struct SetShortDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetShortDescription<St> {}
+    impl<St: State> State for SetShortDescription<St> {
+        type Country = St::Country;
+        type LongDescription = St::LongDescription;
+        type CreatedAt = St::CreatedAt;
+        type DisplayName = St::DisplayName;
+        type ShortDescription = Set<members::short_description>;
+        type Objectives = St::Objectives;
+        type Visibility = St::Visibility;
     }
     ///State transition - sets the `objectives` field to Set
     pub struct SetObjectives<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetObjectives<St> {}
     impl<St: State> State for SetObjectives<St> {
-        type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
-        type LongDescription = St::LongDescription;
         type Country = St::Country;
+        type LongDescription = St::LongDescription;
+        type CreatedAt = St::CreatedAt;
         type DisplayName = St::DisplayName;
-        type Objectives = Set<members::objectives>;
         type ShortDescription = St::ShortDescription;
-    }
-    ///State transition - sets the `short_description` field to Set
-    pub struct SetShortDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetShortDescription<St> {}
-    impl<St: State> State for SetShortDescription<St> {
+        type Objectives = Set<members::objectives>;
         type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
-        type LongDescription = St::LongDescription;
+    }
+    ///State transition - sets the `visibility` field to Set
+    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVisibility<St> {}
+    impl<St: State> State for SetVisibility<St> {
         type Country = St::Country;
+        type LongDescription = St::LongDescription;
+        type CreatedAt = St::CreatedAt;
         type DisplayName = St::DisplayName;
+        type ShortDescription = St::ShortDescription;
         type Objectives = St::Objectives;
-        type ShortDescription = Set<members::short_description>;
+        type Visibility = Set<members::visibility>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `visibility` field
-        pub struct visibility(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `long_description` field
-        pub struct long_description(());
         ///Marker type for the `country` field
         pub struct country(());
+        ///Marker type for the `long_description` field
+        pub struct long_description(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
-        ///Marker type for the `objectives` field
-        pub struct objectives(());
         ///Marker type for the `short_description` field
         pub struct short_description(());
+        ///Marker type for the `objectives` field
+        pub struct objectives(());
+        ///Marker type for the `visibility` field
+        pub struct visibility(());
     }
 }
 
@@ -551,13 +551,13 @@ impl<S: BosStr, St: info_state::State> InfoBuilder<S, St> {
 impl<S: BosStr, St> InfoBuilder<S, St>
 where
     St: info_state::State,
-    St::Visibility: info_state::IsSet,
-    St::CreatedAt: info_state::IsSet,
-    St::LongDescription: info_state::IsSet,
     St::Country: info_state::IsSet,
+    St::LongDescription: info_state::IsSet,
+    St::CreatedAt: info_state::IsSet,
     St::DisplayName: info_state::IsSet,
-    St::Objectives: info_state::IsSet,
     St::ShortDescription: info_state::IsSet,
+    St::Objectives: info_state::IsSet,
+    St::Visibility: info_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Info<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/layer.rs b/crates/jacquard-api/src/app_gainforest/organization/layer.rs
index 40c6ea7d..19a57d6b 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/layer.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/layer.rs
@@ -122,66 +122,66 @@ pub mod layer_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Type;
-        type Name;
-        type Uri;
         type CreatedAt;
+        type Uri;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Type = Unset;
-        type Name = Unset;
-        type Uri = Unset;
         type CreatedAt = Unset;
+        type Uri = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
         type Type = Set<members::r#type>;
-        type Name = St::Name;
-        type Uri = St::Uri;
         type CreatedAt = St::CreatedAt;
+        type Uri = St::Uri;
+        type Name = St::Name;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Type = St::Type;
-        type Name = Set<members::name>;
+        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Type = St::Type;
-        type Name = St::Name;
-        type Uri = Set<members::uri>;
         type CreatedAt = St::CreatedAt;
+        type Uri = Set<members::uri>;
+        type Name = St::Name;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
         type Type = St::Type;
-        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type CreatedAt = Set<members::created_at>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `type` field
         pub struct r#type(());
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -303,9 +303,9 @@ impl<S: BosStr, St> LayerBuilder<S, St>
 where
     St: layer_state::State,
     St::Type: layer_state::IsSet,
-    St::Name: layer_state::IsSet,
-    St::Uri: layer_state::IsSet,
     St::CreatedAt: layer_state::IsSet,
+    St::Uri: layer_state::IsSet,
+    St::Name: layer_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Layer<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/observations/fauna.rs b/crates/jacquard-api/src/app_gainforest/organization/observations/fauna.rs
index b02dd072..6d21ed35 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/observations/fauna.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/observations/fauna.rs
@@ -114,37 +114,37 @@ pub mod fauna_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type GbifTaxonKeys;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type GbifTaxonKeys = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type GbifTaxonKeys = St::GbifTaxonKeys;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `gbif_taxon_keys` field to Set
     pub struct SetGbifTaxonKeys<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGbifTaxonKeys<St> {}
     impl<St: State> State for SetGbifTaxonKeys<St> {
-        type CreatedAt = St::CreatedAt;
         type GbifTaxonKeys = Set<members::gbif_taxon_keys>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type GbifTaxonKeys = St::GbifTaxonKeys;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `gbif_taxon_keys` field
         pub struct gbif_taxon_keys(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> FaunaBuilder<S, St>
 where
     St: fauna_state::State,
-    St::CreatedAt: fauna_state::IsSet,
     St::GbifTaxonKeys: fauna_state::IsSet,
+    St::CreatedAt: fauna_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Fauna<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/predictions/fauna.rs b/crates/jacquard-api/src/app_gainforest/organization/predictions/fauna.rs
index 9f4c2dd4..fadeb6f5 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/predictions/fauna.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/predictions/fauna.rs
@@ -114,37 +114,37 @@ pub mod fauna_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type GbifTaxonKeys;
         type CreatedAt;
+        type GbifTaxonKeys;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type GbifTaxonKeys = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `gbif_taxon_keys` field to Set
-    pub struct SetGbifTaxonKeys<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGbifTaxonKeys<St> {}
-    impl<St: State> State for SetGbifTaxonKeys<St> {
-        type GbifTaxonKeys = Set<members::gbif_taxon_keys>;
-        type CreatedAt = St::CreatedAt;
+        type GbifTaxonKeys = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type GbifTaxonKeys = St::GbifTaxonKeys;
         type CreatedAt = Set<members::created_at>;
+        type GbifTaxonKeys = St::GbifTaxonKeys;
+    }
+    ///State transition - sets the `gbif_taxon_keys` field to Set
+    pub struct SetGbifTaxonKeys<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGbifTaxonKeys<St> {}
+    impl<St: State> State for SetGbifTaxonKeys<St> {
+        type CreatedAt = St::CreatedAt;
+        type GbifTaxonKeys = Set<members::gbif_taxon_keys>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `gbif_taxon_keys` field
-        pub struct gbif_taxon_keys(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `gbif_taxon_keys` field
+        pub struct gbif_taxon_keys(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> FaunaBuilder<S, St>
 where
     St: fauna_state::State,
-    St::GbifTaxonKeys: fauna_state::IsSet,
     St::CreatedAt: fauna_state::IsSet,
+    St::GbifTaxonKeys: fauna_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Fauna<S> {
diff --git a/crates/jacquard-api/src/app_gainforest/organization/predictions/flora.rs b/crates/jacquard-api/src/app_gainforest/organization/predictions/flora.rs
index a8e448fd..c3278104 100644
--- a/crates/jacquard-api/src/app_gainforest/organization/predictions/flora.rs
+++ b/crates/jacquard-api/src/app_gainforest/organization/predictions/flora.rs
@@ -114,37 +114,37 @@ pub mod flora_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type GbifTaxonKeys;
         type CreatedAt;
+        type GbifTaxonKeys;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type GbifTaxonKeys = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `gbif_taxon_keys` field to Set
-    pub struct SetGbifTaxonKeys<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGbifTaxonKeys<St> {}
-    impl<St: State> State for SetGbifTaxonKeys<St> {
-        type GbifTaxonKeys = Set<members::gbif_taxon_keys>;
-        type CreatedAt = St::CreatedAt;
+        type GbifTaxonKeys = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type GbifTaxonKeys = St::GbifTaxonKeys;
         type CreatedAt = Set<members::created_at>;
+        type GbifTaxonKeys = St::GbifTaxonKeys;
+    }
+    ///State transition - sets the `gbif_taxon_keys` field to Set
+    pub struct SetGbifTaxonKeys<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGbifTaxonKeys<St> {}
+    impl<St: State> State for SetGbifTaxonKeys<St> {
+        type CreatedAt = St::CreatedAt;
+        type GbifTaxonKeys = Set<members::gbif_taxon_keys>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `gbif_taxon_keys` field
-        pub struct gbif_taxon_keys(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `gbif_taxon_keys` field
+        pub struct gbif_taxon_keys(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> FloraBuilder<S, St>
 where
     St: flora_state::State,
-    St::GbifTaxonKeys: flora_state::IsSet,
     St::CreatedAt: flora_state::IsSet,
+    St::GbifTaxonKeys: flora_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Flora<S> {
diff --git a/crates/jacquard-api/src/app_greengale/document.rs b/crates/jacquard-api/src/app_greengale/document.rs
index 60b55629..3dc04aeb 100644
--- a/crates/jacquard-api/src/app_greengale/document.rs
+++ b/crates/jacquard-api/src/app_greengale/document.rs
@@ -544,8 +544,8 @@ pub mod document_state {
         type Title;
         type PublishedAt;
         type Content;
-        type Path;
         type Url;
+        type Path;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -554,8 +554,8 @@ pub mod document_state {
         type Title = Unset;
         type PublishedAt = Unset;
         type Content = Unset;
-        type Path = Unset;
         type Url = Unset;
+        type Path = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
@@ -564,8 +564,8 @@ pub mod document_state {
         type Title = Set<members::title>;
         type PublishedAt = St::PublishedAt;
         type Content = St::Content;
-        type Path = St::Path;
         type Url = St::Url;
+        type Path = St::Path;
     }
     ///State transition - sets the `published_at` field to Set
     pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -574,8 +574,8 @@ pub mod document_state {
         type Title = St::Title;
         type PublishedAt = Set<members::published_at>;
         type Content = St::Content;
-        type Path = St::Path;
         type Url = St::Url;
+        type Path = St::Path;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
@@ -584,18 +584,8 @@ pub mod document_state {
         type Title = St::Title;
         type PublishedAt = St::PublishedAt;
         type Content = Set<members::content>;
-        type Path = St::Path;
-        type Url = St::Url;
-    }
-    ///State transition - sets the `path` field to Set
-    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPath<St> {}
-    impl<St: State> State for SetPath<St> {
-        type Title = St::Title;
-        type PublishedAt = St::PublishedAt;
-        type Content = St::Content;
-        type Path = Set<members::path>;
         type Url = St::Url;
+        type Path = St::Path;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
@@ -604,8 +594,18 @@ pub mod document_state {
         type Title = St::Title;
         type PublishedAt = St::PublishedAt;
         type Content = St::Content;
-        type Path = St::Path;
         type Url = Set<members::url>;
+        type Path = St::Path;
+    }
+    ///State transition - sets the `path` field to Set
+    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPath<St> {}
+    impl<St: State> State for SetPath<St> {
+        type Title = St::Title;
+        type PublishedAt = St::PublishedAt;
+        type Content = St::Content;
+        type Url = St::Url;
+        type Path = Set<members::path>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -616,10 +616,10 @@ pub mod document_state {
         pub struct published_at(());
         ///Marker type for the `content` field
         pub struct content(());
-        ///Marker type for the `path` field
-        pub struct path(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `path` field
+        pub struct path(());
     }
 }
 
@@ -866,8 +866,8 @@ where
     St::Title: document_state::IsSet,
     St::PublishedAt: document_state::IsSet,
     St::Content: document_state::IsSet,
-    St::Path: document_state::IsSet,
     St::Url: document_state::IsSet,
+    St::Path: document_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Document<S> {
diff --git a/crates/jacquard-api/src/app_greengale/publication.rs b/crates/jacquard-api/src/app_greengale/publication.rs
index cf0cfac9..df269b20 100644
--- a/crates/jacquard-api/src/app_greengale/publication.rs
+++ b/crates/jacquard-api/src/app_greengale/publication.rs
@@ -165,37 +165,37 @@ pub mod publication_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Url;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Url = St::Url;
+        type Name = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type Name = St::Name;
         type Url = Set<members::url>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Url = St::Url;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -324,8 +324,8 @@ impl<S: BosStr, St: publication_state::State> PublicationBuilder<S, St> {
 impl<S: BosStr, St> PublicationBuilder<S, St>
 where
     St: publication_state::State,
-    St::Name: publication_state::IsSet,
     St::Url: publication_state::IsSet,
+    St::Name: publication_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Publication<S> {
diff --git a/crates/jacquard-api/src/app_mathr/leaderboard/entry.rs b/crates/jacquard-api/src/app_mathr/leaderboard/entry.rs
index 8dac137f..e972c0d4 100644
--- a/crates/jacquard-api/src/app_mathr/leaderboard/entry.rs
+++ b/crates/jacquard-api/src/app_mathr/leaderboard/entry.rs
@@ -183,85 +183,85 @@ pub mod entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type TotalChallenges;
         type Level;
-        type TotalSuccesses;
         type PlayerDid;
-        type TotalChallenges;
         type CreatedAt;
+        type TotalSuccesses;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type TotalChallenges = Unset;
         type Level = Unset;
-        type TotalSuccesses = Unset;
         type PlayerDid = Unset;
-        type TotalChallenges = Unset;
         type CreatedAt = Unset;
+        type TotalSuccesses = Unset;
+    }
+    ///State transition - sets the `total_challenges` field to Set
+    pub struct SetTotalChallenges<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalChallenges<St> {}
+    impl<St: State> State for SetTotalChallenges<St> {
+        type TotalChallenges = Set<members::total_challenges>;
+        type Level = St::Level;
+        type PlayerDid = St::PlayerDid;
+        type CreatedAt = St::CreatedAt;
+        type TotalSuccesses = St::TotalSuccesses;
     }
     ///State transition - sets the `level` field to Set
     pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLevel<St> {}
     impl<St: State> State for SetLevel<St> {
-        type Level = Set<members::level>;
-        type TotalSuccesses = St::TotalSuccesses;
-        type PlayerDid = St::PlayerDid;
         type TotalChallenges = St::TotalChallenges;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `total_successes` field to Set
-    pub struct SetTotalSuccesses<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalSuccesses<St> {}
-    impl<St: State> State for SetTotalSuccesses<St> {
-        type Level = St::Level;
-        type TotalSuccesses = Set<members::total_successes>;
+        type Level = Set<members::level>;
         type PlayerDid = St::PlayerDid;
-        type TotalChallenges = St::TotalChallenges;
         type CreatedAt = St::CreatedAt;
+        type TotalSuccesses = St::TotalSuccesses;
     }
     ///State transition - sets the `player_did` field to Set
     pub struct SetPlayerDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlayerDid<St> {}
     impl<St: State> State for SetPlayerDid<St> {
+        type TotalChallenges = St::TotalChallenges;
         type Level = St::Level;
-        type TotalSuccesses = St::TotalSuccesses;
         type PlayerDid = Set<members::player_did>;
-        type TotalChallenges = St::TotalChallenges;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `total_challenges` field to Set
-    pub struct SetTotalChallenges<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalChallenges<St> {}
-    impl<St: State> State for SetTotalChallenges<St> {
-        type Level = St::Level;
         type TotalSuccesses = St::TotalSuccesses;
-        type PlayerDid = St::PlayerDid;
-        type TotalChallenges = Set<members::total_challenges>;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type TotalChallenges = St::TotalChallenges;
         type Level = St::Level;
-        type TotalSuccesses = St::TotalSuccesses;
         type PlayerDid = St::PlayerDid;
-        type TotalChallenges = St::TotalChallenges;
         type CreatedAt = Set<members::created_at>;
+        type TotalSuccesses = St::TotalSuccesses;
+    }
+    ///State transition - sets the `total_successes` field to Set
+    pub struct SetTotalSuccesses<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalSuccesses<St> {}
+    impl<St: State> State for SetTotalSuccesses<St> {
+        type TotalChallenges = St::TotalChallenges;
+        type Level = St::Level;
+        type PlayerDid = St::PlayerDid;
+        type CreatedAt = St::CreatedAt;
+        type TotalSuccesses = Set<members::total_successes>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `total_challenges` field
+        pub struct total_challenges(());
         ///Marker type for the `level` field
         pub struct level(());
-        ///Marker type for the `total_successes` field
-        pub struct total_successes(());
         ///Marker type for the `player_did` field
         pub struct player_did(());
-        ///Marker type for the `total_challenges` field
-        pub struct total_challenges(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `total_successes` field
+        pub struct total_successes(());
     }
 }
 
@@ -464,11 +464,11 @@ where
 impl<S: BosStr, St> EntryBuilder<S, St>
 where
     St: entry_state::State,
+    St::TotalChallenges: entry_state::IsSet,
     St::Level: entry_state::IsSet,
-    St::TotalSuccesses: entry_state::IsSet,
     St::PlayerDid: entry_state::IsSet,
-    St::TotalChallenges: entry_state::IsSet,
     St::CreatedAt: entry_state::IsSet,
+    St::TotalSuccesses: entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Entry<S> {
diff --git a/crates/jacquard-api/src/app_mathr/score.rs b/crates/jacquard-api/src/app_mathr/score.rs
index 9eba7c04..174d5a8a 100644
--- a/crates/jacquard-api/src/app_mathr/score.rs
+++ b/crates/jacquard-api/src/app_mathr/score.rs
@@ -169,67 +169,67 @@ pub mod score_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Level;
+        type TotalChallenges;
         type TotalSuccesses;
+        type Level;
         type CreatedAt;
-        type TotalChallenges;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Level = Unset;
+        type TotalChallenges = Unset;
         type TotalSuccesses = Unset;
+        type Level = Unset;
         type CreatedAt = Unset;
-        type TotalChallenges = Unset;
     }
-    ///State transition - sets the `level` field to Set
-    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLevel<St> {}
-    impl<St: State> State for SetLevel<St> {
-        type Level = Set<members::level>;
+    ///State transition - sets the `total_challenges` field to Set
+    pub struct SetTotalChallenges<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalChallenges<St> {}
+    impl<St: State> State for SetTotalChallenges<St> {
+        type TotalChallenges = Set<members::total_challenges>;
         type TotalSuccesses = St::TotalSuccesses;
+        type Level = St::Level;
         type CreatedAt = St::CreatedAt;
-        type TotalChallenges = St::TotalChallenges;
     }
     ///State transition - sets the `total_successes` field to Set
     pub struct SetTotalSuccesses<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotalSuccesses<St> {}
     impl<St: State> State for SetTotalSuccesses<St> {
-        type Level = St::Level;
+        type TotalChallenges = St::TotalChallenges;
         type TotalSuccesses = Set<members::total_successes>;
+        type Level = St::Level;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `level` field to Set
+    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLevel<St> {}
+    impl<St: State> State for SetLevel<St> {
         type TotalChallenges = St::TotalChallenges;
+        type TotalSuccesses = St::TotalSuccesses;
+        type Level = Set<members::level>;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Level = St::Level;
-        type TotalSuccesses = St::TotalSuccesses;
-        type CreatedAt = Set<members::created_at>;
         type TotalChallenges = St::TotalChallenges;
-    }
-    ///State transition - sets the `total_challenges` field to Set
-    pub struct SetTotalChallenges<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalChallenges<St> {}
-    impl<St: State> State for SetTotalChallenges<St> {
-        type Level = St::Level;
         type TotalSuccesses = St::TotalSuccesses;
-        type CreatedAt = St::CreatedAt;
-        type TotalChallenges = Set<members::total_challenges>;
+        type Level = St::Level;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `level` field
-        pub struct level(());
+        ///Marker type for the `total_challenges` field
+        pub struct total_challenges(());
         ///Marker type for the `total_successes` field
         pub struct total_successes(());
+        ///Marker type for the `level` field
+        pub struct level(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `total_challenges` field
-        pub struct total_challenges(());
     }
 }
 
@@ -350,10 +350,10 @@ where
 impl<S: BosStr, St> ScoreBuilder<S, St>
 where
     St: score_state::State,
-    St::Level: score_state::IsSet,
+    St::TotalChallenges: score_state::IsSet,
     St::TotalSuccesses: score_state::IsSet,
+    St::Level: score_state::IsSet,
     St::CreatedAt: score_state::IsSet,
-    St::TotalChallenges: score_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Score<S> {
diff --git a/crates/jacquard-api/src/app_nblr/feed/collection.rs b/crates/jacquard-api/src/app_nblr/feed/collection.rs
index 874277ba..87794834 100644
--- a/crates/jacquard-api/src/app_nblr/feed/collection.rs
+++ b/crates/jacquard-api/src/app_nblr/feed/collection.rs
@@ -137,37 +137,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -237,8 +237,8 @@ where
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::CreatedAt: collection_state::IsSet,
     St::Name: collection_state::IsSet,
+    St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/app_nblr/feed/link.rs b/crates/jacquard-api/src/app_nblr/feed/link.rs
index fe81cbcf..cd552a42 100644
--- a/crates/jacquard-api/src/app_nblr/feed/link.rs
+++ b/crates/jacquard-api/src/app_nblr/feed/link.rs
@@ -115,49 +115,49 @@ pub mod link_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Collection;
+        type Uri;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Collection = Unset;
+        type Uri = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Collection = St::Collection;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Uri = St::Uri;
         type Collection = Set<members::collection>;
+        type Uri = St::Uri;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Collection = St::Collection;
+        type Uri = Set<members::uri>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Uri = St::Uri;
         type Collection = St::Collection;
+        type Uri = St::Uri;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `collection` field
         pub struct collection(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -248,8 +248,8 @@ where
 impl<S: BosStr, St> LinkBuilder<S, St>
 where
     St: link_state::State,
-    St::Uri: link_state::IsSet,
     St::Collection: link_state::IsSet,
+    St::Uri: link_state::IsSet,
     St::CreatedAt: link_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_ocho/auth.rs b/crates/jacquard-api/src/app_ocho/auth.rs
index 8981d683..15462d66 100644
--- a/crates/jacquard-api/src/app_ocho/auth.rs
+++ b/crates/jacquard-api/src/app_ocho/auth.rs
@@ -71,67 +71,67 @@ pub mod auth_callback_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AccessJwt;
-        type Did;
         type RefreshJwt;
+        type Did;
         type Handle;
+        type AccessJwt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AccessJwt = Unset;
-        type Did = Unset;
         type RefreshJwt = Unset;
+        type Did = Unset;
         type Handle = Unset;
+        type AccessJwt = Unset;
     }
-    ///State transition - sets the `access_jwt` field to Set
-    pub struct SetAccessJwt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAccessJwt<St> {}
-    impl<St: State> State for SetAccessJwt<St> {
-        type AccessJwt = Set<members::access_jwt>;
+    ///State transition - sets the `refresh_jwt` field to Set
+    pub struct SetRefreshJwt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRefreshJwt<St> {}
+    impl<St: State> State for SetRefreshJwt<St> {
+        type RefreshJwt = Set<members::refresh_jwt>;
         type Did = St::Did;
-        type RefreshJwt = St::RefreshJwt;
         type Handle = St::Handle;
+        type AccessJwt = St::AccessJwt;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type AccessJwt = St::AccessJwt;
-        type Did = Set<members::did>;
         type RefreshJwt = St::RefreshJwt;
+        type Did = Set<members::did>;
         type Handle = St::Handle;
-    }
-    ///State transition - sets the `refresh_jwt` field to Set
-    pub struct SetRefreshJwt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRefreshJwt<St> {}
-    impl<St: State> State for SetRefreshJwt<St> {
         type AccessJwt = St::AccessJwt;
-        type Did = St::Did;
-        type RefreshJwt = Set<members::refresh_jwt>;
-        type Handle = St::Handle;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type AccessJwt = St::AccessJwt;
-        type Did = St::Did;
         type RefreshJwt = St::RefreshJwt;
+        type Did = St::Did;
         type Handle = Set<members::handle>;
+        type AccessJwt = St::AccessJwt;
+    }
+    ///State transition - sets the `access_jwt` field to Set
+    pub struct SetAccessJwt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAccessJwt<St> {}
+    impl<St: State> State for SetAccessJwt<St> {
+        type RefreshJwt = St::RefreshJwt;
+        type Did = St::Did;
+        type Handle = St::Handle;
+        type AccessJwt = Set<members::access_jwt>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `access_jwt` field
-        pub struct access_jwt(());
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `refresh_jwt` field
         pub struct refresh_jwt(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `access_jwt` field
+        pub struct access_jwt(());
     }
 }
 
@@ -239,10 +239,10 @@ where
 impl<S: BosStr, St> AuthCallbackBuilder<S, St>
 where
     St: auth_callback_state::State,
-    St::AccessJwt: auth_callback_state::IsSet,
-    St::Did: auth_callback_state::IsSet,
     St::RefreshJwt: auth_callback_state::IsSet,
+    St::Did: auth_callback_state::IsSet,
     St::Handle: auth_callback_state::IsSet,
+    St::AccessJwt: auth_callback_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AuthCallback<S> {
diff --git a/crates/jacquard-api/src/app_ocho/auth/at_proto_callback.rs b/crates/jacquard-api/src/app_ocho/auth/at_proto_callback.rs
index 7a33340f..6cd0737a 100644
--- a/crates/jacquard-api/src/app_ocho/auth/at_proto_callback.rs
+++ b/crates/jacquard-api/src/app_ocho/auth/at_proto_callback.rs
@@ -58,49 +58,49 @@ pub mod at_proto_callback_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type State;
         type Code;
+        type State;
         type Iss;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type State = Unset;
         type Code = Unset;
+        type State = Unset;
         type Iss = Unset;
     }
-    ///State transition - sets the `state` field to Set
-    pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetState<St> {}
-    impl<St: State> State for SetState<St> {
-        type State = Set<members::state>;
-        type Code = St::Code;
-        type Iss = St::Iss;
-    }
     ///State transition - sets the `code` field to Set
     pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCode<St> {}
     impl<St: State> State for SetCode<St> {
-        type State = St::State;
         type Code = Set<members::code>;
+        type State = St::State;
+        type Iss = St::Iss;
+    }
+    ///State transition - sets the `state` field to Set
+    pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetState<St> {}
+    impl<St: State> State for SetState<St> {
+        type Code = St::Code;
+        type State = Set<members::state>;
         type Iss = St::Iss;
     }
     ///State transition - sets the `iss` field to Set
     pub struct SetIss<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIss<St> {}
     impl<St: State> State for SetIss<St> {
-        type State = St::State;
         type Code = St::Code;
+        type State = St::State;
         type Iss = Set<members::iss>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `state` field
-        pub struct state(());
         ///Marker type for the `code` field
         pub struct code(());
+        ///Marker type for the `state` field
+        pub struct state(());
         ///Marker type for the `iss` field
         pub struct iss(());
     }
@@ -191,8 +191,8 @@ where
 impl<S: BosStr, St> AtProtoCallbackBuilder<S, St>
 where
     St: at_proto_callback_state::State,
-    St::State: at_proto_callback_state::IsSet,
     St::Code: at_proto_callback_state::IsSet,
+    St::State: at_proto_callback_state::IsSet,
     St::Iss: at_proto_callback_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_ocho/auth/google_callback.rs b/crates/jacquard-api/src/app_ocho/auth/google_callback.rs
index 4181bf10..330a1c69 100644
--- a/crates/jacquard-api/src/app_ocho/auth/google_callback.rs
+++ b/crates/jacquard-api/src/app_ocho/auth/google_callback.rs
@@ -57,37 +57,37 @@ pub mod google_callback_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Code;
         type State;
+        type Code;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Code = Unset;
         type State = Unset;
-    }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
-        type Code = Set<members::code>;
-        type State = St::State;
+        type Code = Unset;
     }
     ///State transition - sets the `state` field to Set
     pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetState<St> {}
     impl<St: State> State for SetState<St> {
-        type Code = St::Code;
         type State = Set<members::state>;
+        type Code = St::Code;
+    }
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
+        type State = St::State;
+        type Code = Set<members::code>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `code` field
-        pub struct code(());
         ///Marker type for the `state` field
         pub struct state(());
+        ///Marker type for the `code` field
+        pub struct code(());
     }
 }
 
@@ -157,8 +157,8 @@ where
 impl<S: BosStr, St> GoogleCallbackBuilder<S, St>
 where
     St: google_callback_state::State,
-    St::Code: google_callback_state::IsSet,
     St::State: google_callback_state::IsSet,
+    St::Code: google_callback_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GoogleCallback<S> {
diff --git a/crates/jacquard-api/src/app_ocho/edu/google_callback.rs b/crates/jacquard-api/src/app_ocho/edu/google_callback.rs
index dd56cfa2..b07e81ab 100644
--- a/crates/jacquard-api/src/app_ocho/edu/google_callback.rs
+++ b/crates/jacquard-api/src/app_ocho/edu/google_callback.rs
@@ -57,37 +57,37 @@ pub mod google_callback_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type State;
         type Code;
+        type State;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type State = Unset;
         type Code = Unset;
-    }
-    ///State transition - sets the `state` field to Set
-    pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetState<St> {}
-    impl<St: State> State for SetState<St> {
-        type State = Set<members::state>;
-        type Code = St::Code;
+        type State = Unset;
     }
     ///State transition - sets the `code` field to Set
     pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCode<St> {}
     impl<St: State> State for SetCode<St> {
-        type State = St::State;
         type Code = Set<members::code>;
+        type State = St::State;
+    }
+    ///State transition - sets the `state` field to Set
+    pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetState<St> {}
+    impl<St: State> State for SetState<St> {
+        type Code = St::Code;
+        type State = Set<members::state>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `state` field
-        pub struct state(());
         ///Marker type for the `code` field
         pub struct code(());
+        ///Marker type for the `state` field
+        pub struct state(());
     }
 }
 
@@ -157,8 +157,8 @@ where
 impl<S: BosStr, St> GoogleCallbackBuilder<S, St>
 where
     St: google_callback_state::State,
-    St::State: google_callback_state::IsSet,
     St::Code: google_callback_state::IsSet,
+    St::State: google_callback_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GoogleCallback<S> {
diff --git a/crates/jacquard-api/src/app_ocho/payment/get_stripe_intent.rs b/crates/jacquard-api/src/app_ocho/payment/get_stripe_intent.rs
index cc22f608..1567b2db 100644
--- a/crates/jacquard-api/src/app_ocho/payment/get_stripe_intent.rs
+++ b/crates/jacquard-api/src/app_ocho/payment/get_stripe_intent.rs
@@ -80,51 +80,51 @@ pub mod get_stripe_intent_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Id;
-        type Amount;
         type Iss;
+        type Amount;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Id = Unset;
-        type Amount = Unset;
         type Iss = Unset;
+        type Amount = Unset;
+        type Id = Unset;
     }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
+    ///State transition - sets the `iss` field to Set
+    pub struct SetIss<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIss<St> {}
+    impl<St: State> State for SetIss<St> {
+        type Iss = Set<members::iss>;
         type Amount = St::Amount;
-        type Iss = St::Iss;
+        type Id = St::Id;
     }
     ///State transition - sets the `amount` field to Set
     pub struct SetAmount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAmount<St> {}
     impl<St: State> State for SetAmount<St> {
-        type Id = St::Id;
-        type Amount = Set<members::amount>;
         type Iss = St::Iss;
-    }
-    ///State transition - sets the `iss` field to Set
-    pub struct SetIss<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIss<St> {}
-    impl<St: State> State for SetIss<St> {
+        type Amount = Set<members::amount>;
         type Id = St::Id;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Iss = St::Iss;
         type Amount = St::Amount;
-        type Iss = Set<members::iss>;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `id` field
-        pub struct id(());
-        ///Marker type for the `amount` field
-        pub struct amount(());
         ///Marker type for the `iss` field
         pub struct iss(());
+        ///Marker type for the `amount` field
+        pub struct amount(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -226,9 +226,9 @@ impl<S: BosStr, St: get_stripe_intent_state::State> GetStripeIntentBuilder<S, St
 impl<S: BosStr, St> GetStripeIntentBuilder<S, St>
 where
     St: get_stripe_intent_state::State,
-    St::Id: get_stripe_intent_state::IsSet,
-    St::Amount: get_stripe_intent_state::IsSet,
     St::Iss: get_stripe_intent_state::IsSet,
+    St::Amount: get_stripe_intent_state::IsSet,
+    St::Id: get_stripe_intent_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetStripeIntent<S> {
diff --git a/crates/jacquard-api/src/app_ocho/plugin.rs b/crates/jacquard-api/src/app_ocho/plugin.rs
index 46775133..0c85999c 100644
--- a/crates/jacquard-api/src/app_ocho/plugin.rs
+++ b/crates/jacquard-api/src/app_ocho/plugin.rs
@@ -1099,51 +1099,51 @@ pub mod asset_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Blob;
         type Type;
         type Hash;
+        type Blob;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Blob = Unset;
         type Type = Unset;
         type Hash = Unset;
-    }
-    ///State transition - sets the `blob` field to Set
-    pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlob<St> {}
-    impl<St: State> State for SetBlob<St> {
-        type Blob = Set<members::blob>;
-        type Type = St::Type;
-        type Hash = St::Hash;
+        type Blob = Unset;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type Blob = St::Blob;
         type Type = Set<members::r#type>;
         type Hash = St::Hash;
+        type Blob = St::Blob;
     }
     ///State transition - sets the `hash` field to Set
     pub struct SetHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHash<St> {}
     impl<St: State> State for SetHash<St> {
-        type Blob = St::Blob;
         type Type = St::Type;
         type Hash = Set<members::hash>;
+        type Blob = St::Blob;
+    }
+    ///State transition - sets the `blob` field to Set
+    pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlob<St> {}
+    impl<St: State> State for SetBlob<St> {
+        type Type = St::Type;
+        type Hash = St::Hash;
+        type Blob = Set<members::blob>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `blob` field
-        pub struct blob(());
         ///Marker type for the `type` field
         pub struct r#type(());
         ///Marker type for the `hash` field
         pub struct hash(());
+        ///Marker type for the `blob` field
+        pub struct blob(());
     }
 }
 
@@ -1245,9 +1245,9 @@ impl<S: BosStr, St: asset_state::State> AssetBuilder<S, St> {
 impl<S: BosStr, St> AssetBuilder<S, St>
 where
     St: asset_state::State,
-    St::Blob: asset_state::IsSet,
     St::Type: asset_state::IsSet,
     St::Hash: asset_state::IsSet,
+    St::Blob: asset_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Asset<S> {
@@ -1378,51 +1378,51 @@ pub mod launch_asset_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type ContentType;
         type Url;
         type Key;
-        type ContentType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type ContentType = Unset;
         type Url = Unset;
         type Key = Unset;
-        type ContentType = Unset;
+    }
+    ///State transition - sets the `content_type` field to Set
+    pub struct SetContentType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContentType<St> {}
+    impl<St: State> State for SetContentType<St> {
+        type ContentType = Set<members::content_type>;
+        type Url = St::Url;
+        type Key = St::Key;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
+        type ContentType = St::ContentType;
         type Url = Set<members::url>;
         type Key = St::Key;
-        type ContentType = St::ContentType;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Url = St::Url;
-        type Key = Set<members::key>;
         type ContentType = St::ContentType;
-    }
-    ///State transition - sets the `content_type` field to Set
-    pub struct SetContentType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContentType<St> {}
-    impl<St: State> State for SetContentType<St> {
         type Url = St::Url;
-        type Key = St::Key;
-        type ContentType = Set<members::content_type>;
+        type Key = Set<members::key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `content_type` field
+        pub struct content_type(());
         ///Marker type for the `url` field
         pub struct url(());
         ///Marker type for the `key` field
         pub struct key(());
-        ///Marker type for the `content_type` field
-        pub struct content_type(());
     }
 }
 
@@ -1511,9 +1511,9 @@ where
 impl<S: BosStr, St> LaunchAssetBuilder<S, St>
 where
     St: launch_asset_state::State,
+    St::ContentType: launch_asset_state::IsSet,
     St::Url: launch_asset_state::IsSet,
     St::Key: launch_asset_state::IsSet,
-    St::ContentType: launch_asset_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LaunchAsset<S> {
@@ -1548,103 +1548,103 @@ pub mod manifest_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type LaunchAsset;
         type Metadata;
         type Extra;
-        type Id;
         type CreatedAt;
+        type Id;
+        type LaunchAsset;
         type RuntimeVersion;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type LaunchAsset = Unset;
         type Metadata = Unset;
         type Extra = Unset;
-        type Id = Unset;
         type CreatedAt = Unset;
+        type Id = Unset;
+        type LaunchAsset = Unset;
         type RuntimeVersion = Unset;
     }
-    ///State transition - sets the `launch_asset` field to Set
-    pub struct SetLaunchAsset<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLaunchAsset<St> {}
-    impl<St: State> State for SetLaunchAsset<St> {
-        type LaunchAsset = Set<members::launch_asset>;
-        type Metadata = St::Metadata;
-        type Extra = St::Extra;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type RuntimeVersion = St::RuntimeVersion;
-    }
     ///State transition - sets the `metadata` field to Set
     pub struct SetMetadata<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMetadata<St> {}
     impl<St: State> State for SetMetadata<St> {
-        type LaunchAsset = St::LaunchAsset;
         type Metadata = Set<members::metadata>;
         type Extra = St::Extra;
-        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
+        type Id = St::Id;
+        type LaunchAsset = St::LaunchAsset;
         type RuntimeVersion = St::RuntimeVersion;
     }
     ///State transition - sets the `extra` field to Set
     pub struct SetExtra<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetExtra<St> {}
     impl<St: State> State for SetExtra<St> {
-        type LaunchAsset = St::LaunchAsset;
         type Metadata = St::Metadata;
         type Extra = Set<members::extra>;
-        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
+        type Id = St::Id;
+        type LaunchAsset = St::LaunchAsset;
+        type RuntimeVersion = St::RuntimeVersion;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Metadata = St::Metadata;
+        type Extra = St::Extra;
+        type CreatedAt = Set<members::created_at>;
+        type Id = St::Id;
+        type LaunchAsset = St::LaunchAsset;
         type RuntimeVersion = St::RuntimeVersion;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type LaunchAsset = St::LaunchAsset;
         type Metadata = St::Metadata;
         type Extra = St::Extra;
-        type Id = Set<members::id>;
         type CreatedAt = St::CreatedAt;
+        type Id = Set<members::id>;
+        type LaunchAsset = St::LaunchAsset;
         type RuntimeVersion = St::RuntimeVersion;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type LaunchAsset = St::LaunchAsset;
+    ///State transition - sets the `launch_asset` field to Set
+    pub struct SetLaunchAsset<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLaunchAsset<St> {}
+    impl<St: State> State for SetLaunchAsset<St> {
         type Metadata = St::Metadata;
         type Extra = St::Extra;
+        type CreatedAt = St::CreatedAt;
         type Id = St::Id;
-        type CreatedAt = Set<members::created_at>;
+        type LaunchAsset = Set<members::launch_asset>;
         type RuntimeVersion = St::RuntimeVersion;
     }
     ///State transition - sets the `runtime_version` field to Set
     pub struct SetRuntimeVersion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRuntimeVersion<St> {}
     impl<St: State> State for SetRuntimeVersion<St> {
-        type LaunchAsset = St::LaunchAsset;
         type Metadata = St::Metadata;
         type Extra = St::Extra;
-        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
+        type Id = St::Id;
+        type LaunchAsset = St::LaunchAsset;
         type RuntimeVersion = Set<members::runtime_version>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `launch_asset` field
-        pub struct launch_asset(());
         ///Marker type for the `metadata` field
         pub struct metadata(());
         ///Marker type for the `extra` field
         pub struct extra(());
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `id` field
+        pub struct id(());
+        ///Marker type for the `launch_asset` field
+        pub struct launch_asset(());
         ///Marker type for the `runtime_version` field
         pub struct runtime_version(());
     }
@@ -1799,11 +1799,11 @@ where
 impl<S: BosStr, St> ManifestBuilder<S, St>
 where
     St: manifest_state::State,
-    St::LaunchAsset: manifest_state::IsSet,
     St::Metadata: manifest_state::IsSet,
     St::Extra: manifest_state::IsSet,
-    St::Id: manifest_state::IsSet,
     St::CreatedAt: manifest_state::IsSet,
+    St::Id: manifest_state::IsSet,
+    St::LaunchAsset: manifest_state::IsSet,
     St::RuntimeVersion: manifest_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_ocho/plugin/get_launch_asset.rs b/crates/jacquard-api/src/app_ocho/plugin/get_launch_asset.rs
index 198e6abd..0da74b7f 100644
--- a/crates/jacquard-api/src/app_ocho/plugin/get_launch_asset.rs
+++ b/crates/jacquard-api/src/app_ocho/plugin/get_launch_asset.rs
@@ -86,37 +86,37 @@ pub mod get_launch_asset_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Platform;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Platform = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Platform = St::Platform;
+        type Did = Unset;
     }
     ///State transition - sets the `platform` field to Set
     pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlatform<St> {}
     impl<St: State> State for SetPlatform<St> {
-        type Did = St::Did;
         type Platform = Set<members::platform>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Platform = St::Platform;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `platform` field
         pub struct platform(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -186,8 +186,8 @@ where
 impl<S: BosStr, St> GetLaunchAssetBuilder<S, St>
 where
     St: get_launch_asset_state::State,
-    St::Did: get_launch_asset_state::IsSet,
     St::Platform: get_launch_asset_state::IsSet,
+    St::Did: get_launch_asset_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetLaunchAsset<S> {
diff --git a/crates/jacquard-api/src/app_offprint/block/image.rs b/crates/jacquard-api/src/app_offprint/block/image.rs
index 6e3d0de3..d11f1706 100644
--- a/crates/jacquard-api/src/app_offprint/block/image.rs
+++ b/crates/jacquard-api/src/app_offprint/block/image.rs
@@ -173,37 +173,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Height;
         type Width;
+        type Height;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Height = Unset;
         type Width = Unset;
-    }
-    ///State transition - sets the `height` field to Set
-    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHeight<St> {}
-    impl<St: State> State for SetHeight<St> {
-        type Height = Set<members::height>;
-        type Width = St::Width;
+        type Height = Unset;
     }
     ///State transition - sets the `width` field to Set
     pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidth<St> {}
     impl<St: State> State for SetWidth<St> {
-        type Height = St::Height;
         type Width = Set<members::width>;
+        type Height = St::Height;
+    }
+    ///State transition - sets the `height` field to Set
+    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHeight<St> {}
+    impl<St: State> State for SetHeight<St> {
+        type Width = St::Width;
+        type Height = Set<members::height>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `height` field
-        pub struct height(());
         ///Marker type for the `width` field
         pub struct width(());
+        ///Marker type for the `height` field
+        pub struct height(());
     }
 }
 
@@ -273,8 +273,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Height: aspect_ratio_state::IsSet,
     St::Width: aspect_ratio_state::IsSet,
+    St::Height: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
diff --git a/crates/jacquard-api/src/app_offprint/block/task_list.rs b/crates/jacquard-api/src/app_offprint/block/task_list.rs
index 081083ce..2a3f9465 100644
--- a/crates/jacquard-api/src/app_offprint/block/task_list.rs
+++ b/crates/jacquard-api/src/app_offprint/block/task_list.rs
@@ -267,37 +267,37 @@ pub mod task_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Content;
         type Checked;
+        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Content = Unset;
         type Checked = Unset;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Content = Set<members::content>;
-        type Checked = St::Checked;
+        type Content = Unset;
     }
     ///State transition - sets the `checked` field to Set
     pub struct SetChecked<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetChecked<St> {}
     impl<St: State> State for SetChecked<St> {
-        type Content = St::Content;
         type Checked = Set<members::checked>;
+        type Content = St::Content;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Checked = St::Checked;
+        type Content = Set<members::content>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `content` field
-        pub struct content(());
         ///Marker type for the `checked` field
         pub struct checked(());
+        ///Marker type for the `content` field
+        pub struct content(());
     }
 }
 
@@ -383,8 +383,8 @@ where
 impl<S: BosStr, St> TaskItemBuilder<S, St>
 where
     St: task_item_state::State,
-    St::Content: task_item_state::IsSet,
     St::Checked: task_item_state::IsSet,
+    St::Content: task_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TaskItem<S> {
diff --git a/crates/jacquard-api/src/app_offprint/block/web_bookmark.rs b/crates/jacquard-api/src/app_offprint/block/web_bookmark.rs
index 3ad17c40..b87ed9da 100644
--- a/crates/jacquard-api/src/app_offprint/block/web_bookmark.rs
+++ b/crates/jacquard-api/src/app_offprint/block/web_bookmark.rs
@@ -146,37 +146,37 @@ pub mod web_bookmark_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Href;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Href = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Href = St::Href;
+        type Title = Unset;
     }
     ///State transition - sets the `href` field to Set
     pub struct SetHref<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHref<St> {}
     impl<St: State> State for SetHref<St> {
-        type Title = St::Title;
         type Href = Set<members::href>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Href = St::Href;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `href` field
         pub struct href(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -285,8 +285,8 @@ where
 impl<S: BosStr, St> WebBookmarkBuilder<S, St>
 where
     St: web_bookmark_state::State,
-    St::Title: web_bookmark_state::IsSet,
     St::Href: web_bookmark_state::IsSet,
+    St::Title: web_bookmark_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WebBookmark<S> {
diff --git a/crates/jacquard-api/src/app_openmkt/marketplace/listing.rs b/crates/jacquard-api/src/app_openmkt/marketplace/listing.rs
index 070436ce..89ea33a0 100644
--- a/crates/jacquard-api/src/app_openmkt/marketplace/listing.rs
+++ b/crates/jacquard-api/src/app_openmkt/marketplace/listing.rs
@@ -379,85 +379,85 @@ pub mod listing_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Price;
-        type Category;
-        type Location;
         type Title;
+        type Category;
         type CreatedAt;
+        type Price;
+        type Location;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Price = Unset;
-        type Category = Unset;
-        type Location = Unset;
         type Title = Unset;
+        type Category = Unset;
         type CreatedAt = Unset;
+        type Price = Unset;
+        type Location = Unset;
     }
-    ///State transition - sets the `price` field to Set
-    pub struct SetPrice<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPrice<St> {}
-    impl<St: State> State for SetPrice<St> {
-        type Price = Set<members::price>;
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
         type Category = St::Category;
-        type Location = St::Location;
-        type Title = St::Title;
         type CreatedAt = St::CreatedAt;
+        type Price = St::Price;
+        type Location = St::Location;
     }
     ///State transition - sets the `category` field to Set
     pub struct SetCategory<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCategory<St> {}
     impl<St: State> State for SetCategory<St> {
-        type Price = St::Price;
-        type Category = Set<members::category>;
-        type Location = St::Location;
-        type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `location` field to Set
-    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLocation<St> {}
-    impl<St: State> State for SetLocation<St> {
-        type Price = St::Price;
-        type Category = St::Category;
-        type Location = Set<members::location>;
         type Title = St::Title;
+        type Category = Set<members::category>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
         type Price = St::Price;
-        type Category = St::Category;
         type Location = St::Location;
-        type Title = Set<members::title>;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type Category = St::Category;
+        type CreatedAt = Set<members::created_at>;
         type Price = St::Price;
+        type Location = St::Location;
+    }
+    ///State transition - sets the `price` field to Set
+    pub struct SetPrice<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPrice<St> {}
+    impl<St: State> State for SetPrice<St> {
+        type Title = St::Title;
         type Category = St::Category;
+        type CreatedAt = St::CreatedAt;
+        type Price = Set<members::price>;
         type Location = St::Location;
+    }
+    ///State transition - sets the `location` field to Set
+    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLocation<St> {}
+    impl<St: State> State for SetLocation<St> {
         type Title = St::Title;
-        type CreatedAt = Set<members::created_at>;
+        type Category = St::Category;
+        type CreatedAt = St::CreatedAt;
+        type Price = St::Price;
+        type Location = Set<members::location>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `price` field
-        pub struct price(());
-        ///Marker type for the `category` field
-        pub struct category(());
-        ///Marker type for the `location` field
-        pub struct location(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `category` field
+        pub struct category(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `price` field
+        pub struct price(());
+        ///Marker type for the `location` field
+        pub struct location(());
     }
 }
 
@@ -677,11 +677,11 @@ where
 impl<S: BosStr, St> ListingBuilder<S, St>
 where
     St: listing_state::State,
-    St::Price: listing_state::IsSet,
-    St::Category: listing_state::IsSet,
-    St::Location: listing_state::IsSet,
     St::Title: listing_state::IsSet,
+    St::Category: listing_state::IsSet,
     St::CreatedAt: listing_state::IsSet,
+    St::Price: listing_state::IsSet,
+    St::Location: listing_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Listing<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/allowlist.rs b/crates/jacquard-api/src/app_protoimsg/chat/allowlist.rs
index c94b15e5..7b11ebb5 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/allowlist.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/allowlist.rs
@@ -116,51 +116,51 @@ pub mod allowlist_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Subject;
         type CreatedAt;
         type Room;
-        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Subject = Unset;
         type CreatedAt = Unset;
         type Room = Unset;
-        type Subject = Unset;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+        type Room = St::Room;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
         type Room = St::Room;
-        type Subject = St::Subject;
     }
     ///State transition - sets the `room` field to Set
     pub struct SetRoom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoom<St> {}
     impl<St: State> State for SetRoom<St> {
-        type CreatedAt = St::CreatedAt;
-        type Room = Set<members::room>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type CreatedAt = St::CreatedAt;
-        type Room = St::Room;
-        type Subject = Set<members::subject>;
+        type Room = Set<members::room>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `room` field
         pub struct room(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> AllowlistBuilder<S, St>
 where
     St: allowlist_state::State,
+    St::Subject: allowlist_state::IsSet,
     St::CreatedAt: allowlist_state::IsSet,
     St::Room: allowlist_state::IsSet,
-    St::Subject: allowlist_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Allowlist<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/ban.rs b/crates/jacquard-api/src/app_protoimsg/chat/ban.rs
index 24c92229..1f783dab 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/ban.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/ban.rs
@@ -130,50 +130,50 @@ pub mod ban_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Room;
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Room = Unset;
-        type CreatedAt = Unset;
         type Subject = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `room` field to Set
     pub struct SetRoom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoom<St> {}
     impl<St: State> State for SetRoom<St> {
         type Room = Set<members::room>;
-        type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Room = St::Room;
-        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
         type Room = St::Room;
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Room = St::Room;
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `room` field
         pub struct room(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -276,8 +276,8 @@ impl<S: BosStr, St> BanBuilder<S, St>
 where
     St: ban_state::State,
     St::Room: ban_state::IsSet,
-    St::CreatedAt: ban_state::IsSet,
     St::Subject: ban_state::IsSet,
+    St::CreatedAt: ban_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Ban<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/channel.rs b/crates/jacquard-api/src/app_protoimsg/chat/channel.rs
index 5515429a..99248a8b 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/channel.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/channel.rs
@@ -238,49 +238,49 @@ pub mod channel_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Room;
         type Name;
+        type Room;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Room = Unset;
         type Name = Unset;
+        type Room = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `room` field to Set
-    pub struct SetRoom<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRoom<St> {}
-    impl<St: State> State for SetRoom<St> {
-        type Room = Set<members::room>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Room = St::Room;
         type Name = Set<members::name>;
+        type Room = St::Room;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `room` field to Set
+    pub struct SetRoom<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRoom<St> {}
+    impl<St: State> State for SetRoom<St> {
+        type Name = St::Name;
+        type Room = Set<members::room>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Room = St::Room;
         type Name = St::Name;
+        type Room = St::Room;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `room` field
-        pub struct room(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `room` field
+        pub struct room(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -420,8 +420,8 @@ where
 impl<S: BosStr, St> ChannelBuilder<S, St>
 where
     St: channel_state::State,
-    St::Room: channel_state::IsSet,
     St::Name: channel_state::IsSet,
+    St::Room: channel_state::IsSet,
     St::CreatedAt: channel_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/message.rs b/crates/jacquard-api/src/app_protoimsg/chat/message.rs
index 15f60285..c2066af5 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/message.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/message.rs
@@ -937,37 +937,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -1037,8 +1037,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Width: aspect_ratio_state::IsSet,
     St::Height: aspect_ratio_state::IsSet,
+    St::Width: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
@@ -1658,37 +1658,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteEnd;
         type ByteStart;
+        type ByteEnd;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteEnd = Unset;
         type ByteStart = Unset;
-    }
-    ///State transition - sets the `byte_end` field to Set
-    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
-    impl<St: State> State for SetByteEnd<St> {
-        type ByteEnd = Set<members::byte_end>;
-        type ByteStart = St::ByteStart;
+        type ByteEnd = Unset;
     }
     ///State transition - sets the `byte_start` field to Set
     pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteStart<St> {}
     impl<St: State> State for SetByteStart<St> {
-        type ByteEnd = St::ByteEnd;
         type ByteStart = Set<members::byte_start>;
+        type ByteEnd = St::ByteEnd;
+    }
+    ///State transition - sets the `byte_end` field to Set
+    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
+    impl<St: State> State for SetByteEnd<St> {
+        type ByteStart = St::ByteStart;
+        type ByteEnd = Set<members::byte_end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_end` field
-        pub struct byte_end(());
         ///Marker type for the `byte_start` field
         pub struct byte_start(());
+        ///Marker type for the `byte_end` field
+        pub struct byte_end(());
     }
 }
 
@@ -1758,8 +1758,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteEnd: byte_slice_state::IsSet,
     St::ByteStart: byte_slice_state::IsSet,
+    St::ByteEnd: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
@@ -2056,37 +2056,37 @@ pub mod image_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type Alt;
+        type Image;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type Alt = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type Alt = St::Alt;
+        type Image = Unset;
     }
     ///State transition - sets the `alt` field to Set
     pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlt<St> {}
     impl<St: State> State for SetAlt<St> {
-        type Image = St::Image;
         type Alt = Set<members::alt>;
+        type Image = St::Image;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type Alt = St::Alt;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `alt` field
         pub struct alt(());
+        ///Marker type for the `image` field
+        pub struct image(());
     }
 }
 
@@ -2172,8 +2172,8 @@ where
 impl<S: BosStr, St> ImageItemBuilder<S, St>
 where
     St: image_item_state::State,
-    St::Image: image_item_state::IsSet,
     St::Alt: image_item_state::IsSet,
+    St::Image: image_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ImageItem<S> {
@@ -2305,51 +2305,51 @@ pub mod message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
         type Channel;
         type CreatedAt;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
         type Channel = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
-        type Channel = St::Channel;
-        type CreatedAt = St::CreatedAt;
+        type Text = Unset;
     }
     ///State transition - sets the `channel` field to Set
     pub struct SetChannel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetChannel<St> {}
     impl<St: State> State for SetChannel<St> {
-        type Text = St::Text;
         type Channel = Set<members::channel>;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Text = St::Text;
         type Channel = St::Channel;
         type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type Channel = St::Channel;
+        type CreatedAt = St::CreatedAt;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `channel` field
         pub struct channel(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -2490,9 +2490,9 @@ where
 impl<S: BosStr, St> MessageBuilder<S, St>
 where
     St: message_state::State,
-    St::Text: message_state::IsSet,
     St::Channel: message_state::IsSet,
     St::CreatedAt: message_state::IsSet,
+    St::Text: message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Message<S> {
@@ -2627,37 +2627,37 @@ pub mod reply_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Parent;
         type Root;
+        type Parent;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Parent = Unset;
         type Root = Unset;
-    }
-    ///State transition - sets the `parent` field to Set
-    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetParent<St> {}
-    impl<St: State> State for SetParent<St> {
-        type Parent = Set<members::parent>;
-        type Root = St::Root;
+        type Parent = Unset;
     }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
-        type Parent = St::Parent;
         type Root = Set<members::root>;
+        type Parent = St::Parent;
+    }
+    ///State transition - sets the `parent` field to Set
+    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetParent<St> {}
+    impl<St: State> State for SetParent<St> {
+        type Root = St::Root;
+        type Parent = Set<members::parent>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `parent` field
-        pub struct parent(());
         ///Marker type for the `root` field
         pub struct root(());
+        ///Marker type for the `parent` field
+        pub struct parent(());
     }
 }
 
@@ -2727,8 +2727,8 @@ where
 impl<S: BosStr, St> ReplyRefBuilder<S, St>
 where
     St: reply_ref_state::State,
-    St::Parent: reply_ref_state::IsSet,
     St::Root: reply_ref_state::IsSet,
+    St::Parent: reply_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReplyRef<S> {
@@ -2758,37 +2758,37 @@ pub mod rich_text_facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Features;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Features = St::Features;
+        type Index = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Index = St::Index;
         type Features = Set<members::features>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Features = St::Features;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -2858,8 +2858,8 @@ where
 impl<S: BosStr, St> RichTextFacetBuilder<S, St>
 where
     St: rich_text_facet_state::State,
-    St::Index: rich_text_facet_state::IsSet,
     St::Features: rich_text_facet_state::IsSet,
+    St::Index: rich_text_facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RichTextFacet<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/poll.rs b/crates/jacquard-api/src/app_protoimsg/chat/poll.rs
index 3f499fc7..892d1607 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/poll.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/poll.rs
@@ -162,67 +162,67 @@ pub mod poll_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Options;
-        type Question;
         type Channel;
-        type CreatedAt;
+        type Question;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Options = Unset;
-        type Question = Unset;
         type Channel = Unset;
-        type CreatedAt = Unset;
+        type Question = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Options = St::Options;
+        type Channel = St::Channel;
+        type Question = St::Question;
     }
     ///State transition - sets the `options` field to Set
     pub struct SetOptions<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOptions<St> {}
     impl<St: State> State for SetOptions<St> {
-        type Options = Set<members::options>;
-        type Question = St::Question;
-        type Channel = St::Channel;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `question` field to Set
-    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuestion<St> {}
-    impl<St: State> State for SetQuestion<St> {
-        type Options = St::Options;
-        type Question = Set<members::question>;
+        type Options = Set<members::options>;
         type Channel = St::Channel;
-        type CreatedAt = St::CreatedAt;
+        type Question = St::Question;
     }
     ///State transition - sets the `channel` field to Set
     pub struct SetChannel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetChannel<St> {}
     impl<St: State> State for SetChannel<St> {
+        type CreatedAt = St::CreatedAt;
         type Options = St::Options;
-        type Question = St::Question;
         type Channel = Set<members::channel>;
-        type CreatedAt = St::CreatedAt;
+        type Question = St::Question;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `question` field to Set
+    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuestion<St> {}
+    impl<St: State> State for SetQuestion<St> {
+        type CreatedAt = St::CreatedAt;
         type Options = St::Options;
-        type Question = St::Question;
         type Channel = St::Channel;
-        type CreatedAt = Set<members::created_at>;
+        type Question = Set<members::question>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `options` field
         pub struct options(());
-        ///Marker type for the `question` field
-        pub struct question(());
         ///Marker type for the `channel` field
         pub struct channel(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `question` field
+        pub struct question(());
     }
 }
 
@@ -363,10 +363,10 @@ where
 impl<S: BosStr, St> PollBuilder<S, St>
 where
     St: poll_state::State,
+    St::CreatedAt: poll_state::IsSet,
     St::Options: poll_state::IsSet,
-    St::Question: poll_state::IsSet,
     St::Channel: poll_state::IsSet,
-    St::CreatedAt: poll_state::IsSet,
+    St::Question: poll_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Poll<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/presence.rs b/crates/jacquard-api/src/app_protoimsg/chat/presence.rs
index 23d4fe85..cb32e47c 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/presence.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/presence.rs
@@ -218,37 +218,37 @@ pub mod presence_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type UpdatedAt;
+        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type UpdatedAt = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type UpdatedAt = St::UpdatedAt;
+        type Status = Unset;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
-        type Status = St::Status;
         type UpdatedAt = Set<members::updated_at>;
+        type Status = St::Status;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type Status = Set<members::status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
     }
 }
 
@@ -331,8 +331,8 @@ where
 impl<S: BosStr, St> PresenceBuilder<S, St>
 where
     St: presence_state::State,
-    St::Status: presence_state::IsSet,
     St::UpdatedAt: presence_state::IsSet,
+    St::Status: presence_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Presence<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/role.rs b/crates/jacquard-api/src/app_protoimsg/chat/role.rs
index 174d7317..5099e3f6 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/role.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/role.rs
@@ -197,67 +197,67 @@ pub mod role_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
-        type Room;
         type Role;
+        type Room;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-        type Room = Unset;
         type Role = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
-        type Room = St::Room;
-        type Role = St::Role;
+        type Room = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
-        type Room = St::Room;
         type Role = St::Role;
+        type Room = St::Room;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `role` field to Set
+    pub struct SetRole<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRole<St> {}
+    impl<St: State> State for SetRole<St> {
+        type Subject = St::Subject;
+        type Role = Set<members::role>;
+        type Room = St::Room;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `room` field to Set
     pub struct SetRoom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoom<St> {}
     impl<St: State> State for SetRoom<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = St::Subject;
-        type Room = Set<members::room>;
         type Role = St::Role;
-    }
-    ///State transition - sets the `role` field to Set
-    pub struct SetRole<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRole<St> {}
-    impl<St: State> State for SetRole<St> {
+        type Room = Set<members::room>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Subject = St::Subject;
+        type Role = St::Role;
         type Room = St::Room;
-        type Role = Set<members::role>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `room` field
-        pub struct room(());
         ///Marker type for the `role` field
         pub struct role(());
+        ///Marker type for the `room` field
+        pub struct room(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -365,10 +365,10 @@ where
 impl<S: BosStr, St> RoleBuilder<S, St>
 where
     St: role_state::State,
-    St::CreatedAt: role_state::IsSet,
     St::Subject: role_state::IsSet,
-    St::Room: role_state::IsSet,
     St::Role: role_state::IsSet,
+    St::Room: role_state::IsSet,
+    St::CreatedAt: role_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Role<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/room.rs b/crates/jacquard-api/src/app_protoimsg/chat/room.rs
index ffa5c4a2..a42fbd99 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/room.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/room.rs
@@ -398,67 +398,67 @@ pub mod room_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Topic;
-        type CreatedAt;
         type Name;
         type Purpose;
+        type CreatedAt;
+        type Topic;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Topic = Unset;
-        type CreatedAt = Unset;
         type Name = Unset;
         type Purpose = Unset;
-    }
-    ///State transition - sets the `topic` field to Set
-    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTopic<St> {}
-    impl<St: State> State for SetTopic<St> {
-        type Topic = Set<members::topic>;
-        type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
-        type Purpose = St::Purpose;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Topic = St::Topic;
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
-        type Purpose = St::Purpose;
+        type CreatedAt = Unset;
+        type Topic = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Topic = St::Topic;
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Purpose = St::Purpose;
+        type CreatedAt = St::CreatedAt;
+        type Topic = St::Topic;
     }
     ///State transition - sets the `purpose` field to Set
     pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPurpose<St> {}
     impl<St: State> State for SetPurpose<St> {
-        type Topic = St::Topic;
-        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
         type Purpose = Set<members::purpose>;
+        type CreatedAt = St::CreatedAt;
+        type Topic = St::Topic;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type Purpose = St::Purpose;
+        type CreatedAt = Set<members::created_at>;
+        type Topic = St::Topic;
+    }
+    ///State transition - sets the `topic` field to Set
+    pub struct SetTopic<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTopic<St> {}
+    impl<St: State> State for SetTopic<St> {
+        type Name = St::Name;
+        type Purpose = St::Purpose;
+        type CreatedAt = St::CreatedAt;
+        type Topic = Set<members::topic>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `topic` field
-        pub struct topic(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `purpose` field
         pub struct purpose(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `topic` field
+        pub struct topic(());
     }
 }
 
@@ -613,10 +613,10 @@ where
 impl<S: BosStr, St> RoomBuilder<S, St>
 where
     St: room_state::State,
-    St::Topic: room_state::IsSet,
-    St::CreatedAt: room_state::IsSet,
     St::Name: room_state::IsSet,
     St::Purpose: room_state::IsSet,
+    St::CreatedAt: room_state::IsSet,
+    St::Topic: room_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Room<S> {
diff --git a/crates/jacquard-api/src/app_protoimsg/chat/vote.rs b/crates/jacquard-api/src/app_protoimsg/chat/vote.rs
index c17e1f1e..861d606f 100644
--- a/crates/jacquard-api/src/app_protoimsg/chat/vote.rs
+++ b/crates/jacquard-api/src/app_protoimsg/chat/vote.rs
@@ -127,51 +127,51 @@ pub mod vote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type SelectedOptions;
-        type Poll;
         type CreatedAt;
+        type Poll;
+        type SelectedOptions;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type SelectedOptions = Unset;
-        type Poll = Unset;
         type CreatedAt = Unset;
+        type Poll = Unset;
+        type SelectedOptions = Unset;
     }
-    ///State transition - sets the `selected_options` field to Set
-    pub struct SetSelectedOptions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSelectedOptions<St> {}
-    impl<St: State> State for SetSelectedOptions<St> {
-        type SelectedOptions = Set<members::selected_options>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Poll = St::Poll;
-        type CreatedAt = St::CreatedAt;
+        type SelectedOptions = St::SelectedOptions;
     }
     ///State transition - sets the `poll` field to Set
     pub struct SetPoll<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPoll<St> {}
     impl<St: State> State for SetPoll<St> {
-        type SelectedOptions = St::SelectedOptions;
-        type Poll = Set<members::poll>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Poll = Set<members::poll>;
         type SelectedOptions = St::SelectedOptions;
+    }
+    ///State transition - sets the `selected_options` field to Set
+    pub struct SetSelectedOptions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSelectedOptions<St> {}
+    impl<St: State> State for SetSelectedOptions<St> {
+        type CreatedAt = St::CreatedAt;
         type Poll = St::Poll;
-        type CreatedAt = Set<members::created_at>;
+        type SelectedOptions = Set<members::selected_options>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `selected_options` field
-        pub struct selected_options(());
-        ///Marker type for the `poll` field
-        pub struct poll(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `poll` field
+        pub struct poll(());
+        ///Marker type for the `selected_options` field
+        pub struct selected_options(());
     }
 }
 
@@ -260,9 +260,9 @@ where
 impl<S: BosStr, St> VoteBuilder<S, St>
 where
     St: vote_state::State,
-    St::SelectedOptions: vote_state::IsSet,
-    St::Poll: vote_state::IsSet,
     St::CreatedAt: vote_state::IsSet,
+    St::Poll: vote_state::IsSet,
+    St::SelectedOptions: vote_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Vote<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/album.rs b/crates/jacquard-api/src/app_rocksky/album.rs
index 544ff4f2..c2583ef9 100644
--- a/crates/jacquard-api/src/app_rocksky/album.rs
+++ b/crates/jacquard-api/src/app_rocksky/album.rs
@@ -402,50 +402,50 @@ pub mod album_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Artist;
         type Title;
+        type Artist;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Artist = Unset;
         type Title = Unset;
+        type Artist = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Artist = St::Artist;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
-        type CreatedAt = St::CreatedAt;
-        type Artist = Set<members::artist>;
         type Title = St::Title;
+        type Artist = St::Artist;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
         type CreatedAt = St::CreatedAt;
-        type Artist = St::Artist;
         type Title = Set<members::title>;
+        type Artist = St::Artist;
+    }
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
+        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
+        type Artist = Set<members::artist>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `artist` field
-        pub struct artist(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
     }
 }
 
@@ -708,8 +708,8 @@ impl<S: BosStr, St> AlbumBuilder<S, St>
 where
     St: album_state::State,
     St::CreatedAt: album_state::IsSet,
-    St::Artist: album_state::IsSet,
     St::Title: album_state::IsSet,
+    St::Artist: album_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Album<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/feed/generator.rs b/crates/jacquard-api/src/app_rocksky/feed/generator.rs
index 0a17690a..2f48301f 100644
--- a/crates/jacquard-api/src/app_rocksky/feed/generator.rs
+++ b/crates/jacquard-api/src/app_rocksky/feed/generator.rs
@@ -204,51 +204,51 @@ pub mod generator_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type DisplayName;
         type Did;
+        type DisplayName;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type DisplayName = Unset;
         type Did = Unset;
+        type DisplayName = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Did = Set<members::did>;
         type DisplayName = St::DisplayName;
-        type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
-        type CreatedAt = St::CreatedAt;
-        type DisplayName = Set<members::display_name>;
         type Did = St::Did;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
+        type DisplayName = Set<members::display_name>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Did = St::Did;
         type DisplayName = St::DisplayName;
-        type Did = Set<members::did>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -369,9 +369,9 @@ where
 impl<S: BosStr, St> GeneratorBuilder<S, St>
 where
     St: generator_state::State,
-    St::CreatedAt: generator_state::IsSet,
-    St::DisplayName: generator_state::IsSet,
     St::Did: generator_state::IsSet,
+    St::DisplayName: generator_state::IsSet,
+    St::CreatedAt: generator_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Generator<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/graph/follow.rs b/crates/jacquard-api/src/app_rocksky/graph/follow.rs
index 7d8c66eb..f1c792aa 100644
--- a/crates/jacquard-api/src/app_rocksky/graph/follow.rs
+++ b/crates/jacquard-api/src/app_rocksky/graph/follow.rs
@@ -115,37 +115,37 @@ pub mod follow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -228,8 +228,8 @@ impl<S: BosStr, St: follow_state::State> FollowBuilder<S, St> {
 impl<S: BosStr, St> FollowBuilder<S, St>
 where
     St: follow_state::State,
-    St::Subject: follow_state::IsSet,
     St::CreatedAt: follow_state::IsSet,
+    St::Subject: follow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Follow<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/playlist.rs b/crates/jacquard-api/src/app_rocksky/playlist.rs
index db26b73a..2cfcdc2a 100644
--- a/crates/jacquard-api/src/app_rocksky/playlist.rs
+++ b/crates/jacquard-api/src/app_rocksky/playlist.rs
@@ -347,37 +347,37 @@ pub mod playlist_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -548,8 +548,8 @@ impl<S: BosStr, St: playlist_state::State> PlaylistBuilder<S, St> {
 impl<S: BosStr, St> PlaylistBuilder<S, St>
 where
     St: playlist_state::State,
-    St::Name: playlist_state::IsSet,
     St::CreatedAt: playlist_state::IsSet,
+    St::Name: playlist_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Playlist<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/radio.rs b/crates/jacquard-api/src/app_rocksky/radio.rs
index 9b803469..196a50f3 100644
--- a/crates/jacquard-api/src/app_rocksky/radio.rs
+++ b/crates/jacquard-api/src/app_rocksky/radio.rs
@@ -313,49 +313,49 @@ pub mod radio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Url;
+        type CreatedAt;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Url = Unset;
+        type CreatedAt = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Url = St::Url;
-        type Name = St::Name;
-    }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type CreatedAt = St::CreatedAt;
         type Url = Set<members::url>;
+        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Url = St::Url;
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Url = St::Url;
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -506,8 +506,8 @@ impl<S: BosStr, St: radio_state::State> RadioBuilder<S, St> {
 impl<S: BosStr, St> RadioBuilder<S, St>
 where
     St: radio_state::State,
-    St::CreatedAt: radio_state::IsSet,
     St::Url: radio_state::IsSet,
+    St::CreatedAt: radio_state::IsSet,
     St::Name: radio_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_rocksky/scrobble.rs b/crates/jacquard-api/src/app_rocksky/scrobble.rs
index d9385d15..f156f991 100644
--- a/crates/jacquard-api/src/app_rocksky/scrobble.rs
+++ b/crates/jacquard-api/src/app_rocksky/scrobble.rs
@@ -533,105 +533,105 @@ pub mod scrobble_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type AlbumArtist;
         type Title;
-        type Duration;
+        type Artist;
         type CreatedAt;
-        type AlbumArtist;
         type Album;
-        type Artist;
+        type Duration;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type AlbumArtist = Unset;
         type Title = Unset;
-        type Duration = Unset;
+        type Artist = Unset;
         type CreatedAt = Unset;
-        type AlbumArtist = Unset;
         type Album = Unset;
-        type Artist = Unset;
+        type Duration = Unset;
+    }
+    ///State transition - sets the `album_artist` field to Set
+    pub struct SetAlbumArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAlbumArtist<St> {}
+    impl<St: State> State for SetAlbumArtist<St> {
+        type AlbumArtist = Set<members::album_artist>;
+        type Title = St::Title;
+        type Artist = St::Artist;
+        type CreatedAt = St::CreatedAt;
+        type Album = St::Album;
+        type Duration = St::Duration;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
+        type AlbumArtist = St::AlbumArtist;
         type Title = Set<members::title>;
-        type Duration = St::Duration;
+        type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
-        type AlbumArtist = St::AlbumArtist;
         type Album = St::Album;
-        type Artist = St::Artist;
+        type Duration = St::Duration;
     }
-    ///State transition - sets the `duration` field to Set
-    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDuration<St> {}
-    impl<St: State> State for SetDuration<St> {
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
+        type AlbumArtist = St::AlbumArtist;
         type Title = St::Title;
-        type Duration = Set<members::duration>;
+        type Artist = Set<members::artist>;
         type CreatedAt = St::CreatedAt;
-        type AlbumArtist = St::AlbumArtist;
         type Album = St::Album;
-        type Artist = St::Artist;
+        type Duration = St::Duration;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type AlbumArtist = St::AlbumArtist;
         type Title = St::Title;
-        type Duration = St::Duration;
+        type Artist = St::Artist;
         type CreatedAt = Set<members::created_at>;
-        type AlbumArtist = St::AlbumArtist;
         type Album = St::Album;
-        type Artist = St::Artist;
-    }
-    ///State transition - sets the `album_artist` field to Set
-    pub struct SetAlbumArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAlbumArtist<St> {}
-    impl<St: State> State for SetAlbumArtist<St> {
-        type Title = St::Title;
         type Duration = St::Duration;
-        type CreatedAt = St::CreatedAt;
-        type AlbumArtist = Set<members::album_artist>;
-        type Album = St::Album;
-        type Artist = St::Artist;
     }
     ///State transition - sets the `album` field to Set
     pub struct SetAlbum<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlbum<St> {}
     impl<St: State> State for SetAlbum<St> {
+        type AlbumArtist = St::AlbumArtist;
         type Title = St::Title;
-        type Duration = St::Duration;
+        type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
-        type AlbumArtist = St::AlbumArtist;
         type Album = Set<members::album>;
-        type Artist = St::Artist;
+        type Duration = St::Duration;
     }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
+    ///State transition - sets the `duration` field to Set
+    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDuration<St> {}
+    impl<St: State> State for SetDuration<St> {
+        type AlbumArtist = St::AlbumArtist;
         type Title = St::Title;
-        type Duration = St::Duration;
+        type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
-        type AlbumArtist = St::AlbumArtist;
         type Album = St::Album;
-        type Artist = Set<members::artist>;
+        type Duration = Set<members::duration>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `album_artist` field
+        pub struct album_artist(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `duration` field
-        pub struct duration(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `album_artist` field
-        pub struct album_artist(());
         ///Marker type for the `album` field
         pub struct album(());
-        ///Marker type for the `artist` field
-        pub struct artist(());
+        ///Marker type for the `duration` field
+        pub struct duration(());
     }
 }
 
@@ -1076,12 +1076,12 @@ impl<S: BosStr, St: scrobble_state::State> ScrobbleBuilder<S, St> {
 impl<S: BosStr, St> ScrobbleBuilder<S, St>
 where
     St: scrobble_state::State,
+    St::AlbumArtist: scrobble_state::IsSet,
     St::Title: scrobble_state::IsSet,
-    St::Duration: scrobble_state::IsSet,
+    St::Artist: scrobble_state::IsSet,
     St::CreatedAt: scrobble_state::IsSet,
-    St::AlbumArtist: scrobble_state::IsSet,
     St::Album: scrobble_state::IsSet,
-    St::Artist: scrobble_state::IsSet,
+    St::Duration: scrobble_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Scrobble<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/shout.rs b/crates/jacquard-api/src/app_rocksky/shout.rs
index f7ddeaf7..4828d3cc 100644
--- a/crates/jacquard-api/src/app_rocksky/shout.rs
+++ b/crates/jacquard-api/src/app_rocksky/shout.rs
@@ -229,49 +229,49 @@ pub mod shout_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type Message;
+        type Subject;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type Message = Unset;
+        type Subject = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type Message = St::Message;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type Subject = St::Subject;
         type Message = Set<members::message>;
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Message = St::Message;
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type Message = St::Message;
+        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `message` field
         pub struct message(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -375,8 +375,8 @@ where
 impl<S: BosStr, St> ShoutBuilder<S, St>
 where
     St: shout_state::State,
-    St::Subject: shout_state::IsSet,
     St::Message: shout_state::IsSet,
+    St::Subject: shout_state::IsSet,
     St::CreatedAt: shout_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/app_rocksky/song.rs b/crates/jacquard-api/src/app_rocksky/song.rs
index 24851c8f..1c05723f 100644
--- a/crates/jacquard-api/src/app_rocksky/song.rs
+++ b/crates/jacquard-api/src/app_rocksky/song.rs
@@ -595,105 +595,105 @@ pub mod song_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Artist;
-        type CreatedAt;
         type Duration;
-        type Album;
         type Title;
+        type Album;
         type AlbumArtist;
+        type Artist;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Artist = Unset;
-        type CreatedAt = Unset;
         type Duration = Unset;
-        type Album = Unset;
         type Title = Unset;
+        type Album = Unset;
         type AlbumArtist = Unset;
-    }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
-        type Artist = Set<members::artist>;
-        type CreatedAt = St::CreatedAt;
-        type Duration = St::Duration;
-        type Album = St::Album;
-        type Title = St::Title;
-        type AlbumArtist = St::AlbumArtist;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Artist = St::Artist;
-        type CreatedAt = Set<members::created_at>;
-        type Duration = St::Duration;
-        type Album = St::Album;
-        type Title = St::Title;
-        type AlbumArtist = St::AlbumArtist;
+        type Artist = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `duration` field to Set
     pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDuration<St> {}
     impl<St: State> State for SetDuration<St> {
-        type Artist = St::Artist;
-        type CreatedAt = St::CreatedAt;
         type Duration = Set<members::duration>;
-        type Album = St::Album;
         type Title = St::Title;
+        type Album = St::Album;
         type AlbumArtist = St::AlbumArtist;
-    }
-    ///State transition - sets the `album` field to Set
-    pub struct SetAlbum<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAlbum<St> {}
-    impl<St: State> State for SetAlbum<St> {
         type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
-        type Duration = St::Duration;
-        type Album = Set<members::album>;
-        type Title = St::Title;
-        type AlbumArtist = St::AlbumArtist;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
+        type Duration = St::Duration;
+        type Title = Set<members::title>;
+        type Album = St::Album;
+        type AlbumArtist = St::AlbumArtist;
         type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `album` field to Set
+    pub struct SetAlbum<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAlbum<St> {}
+    impl<St: State> State for SetAlbum<St> {
         type Duration = St::Duration;
-        type Album = St::Album;
-        type Title = Set<members::title>;
+        type Title = St::Title;
+        type Album = Set<members::album>;
         type AlbumArtist = St::AlbumArtist;
+        type Artist = St::Artist;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `album_artist` field to Set
     pub struct SetAlbumArtist<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlbumArtist<St> {}
     impl<St: State> State for SetAlbumArtist<St> {
+        type Duration = St::Duration;
+        type Title = St::Title;
+        type Album = St::Album;
+        type AlbumArtist = Set<members::album_artist>;
         type Artist = St::Artist;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
         type Duration = St::Duration;
+        type Title = St::Title;
         type Album = St::Album;
+        type AlbumArtist = St::AlbumArtist;
+        type Artist = Set<members::artist>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Duration = St::Duration;
         type Title = St::Title;
-        type AlbumArtist = Set<members::album_artist>;
+        type Album = St::Album;
+        type AlbumArtist = St::AlbumArtist;
+        type Artist = St::Artist;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artist` field
-        pub struct artist(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `duration` field
         pub struct duration(());
-        ///Marker type for the `album` field
-        pub struct album(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `album` field
+        pub struct album(());
         ///Marker type for the `album_artist` field
         pub struct album_artist(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -1138,12 +1138,12 @@ impl<S: BosStr, St: song_state::State> SongBuilder<S, St> {
 impl<S: BosStr, St> SongBuilder<S, St>
 where
     St: song_state::State,
-    St::Artist: song_state::IsSet,
-    St::CreatedAt: song_state::IsSet,
     St::Duration: song_state::IsSet,
-    St::Album: song_state::IsSet,
     St::Title: song_state::IsSet,
+    St::Album: song_state::IsSet,
     St::AlbumArtist: song_state::IsSet,
+    St::Artist: song_state::IsSet,
+    St::CreatedAt: song_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Song<S> {
diff --git a/crates/jacquard-api/src/app_rocksky/song/match_song.rs b/crates/jacquard-api/src/app_rocksky/song/match_song.rs
index 74b69d3a..102bd5e7 100644
--- a/crates/jacquard-api/src/app_rocksky/song/match_song.rs
+++ b/crates/jacquard-api/src/app_rocksky/song/match_song.rs
@@ -68,37 +68,37 @@ pub mod match_song_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Artist;
         type Title;
+        type Artist;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Artist = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
-        type Artist = Set<members::artist>;
-        type Title = St::Title;
+        type Artist = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Artist = St::Artist;
         type Title = Set<members::title>;
+        type Artist = St::Artist;
+    }
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
+        type Title = St::Title;
+        type Artist = Set<members::artist>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artist` field
-        pub struct artist(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
     }
 }
 
@@ -168,8 +168,8 @@ where
 impl<S: BosStr, St> MatchSongBuilder<S, St>
 where
     St: match_song_state::State,
-    St::Artist: match_song_state::IsSet,
     St::Title: match_song_state::IsSet,
+    St::Artist: match_song_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MatchSong<S> {
diff --git a/crates/jacquard-api/src/art_cllctv/embed/external.rs b/crates/jacquard-api/src/art_cllctv/embed/external.rs
index da5750a5..6128d44b 100644
--- a/crates/jacquard-api/src/art_cllctv/embed/external.rs
+++ b/crates/jacquard-api/src/art_cllctv/embed/external.rs
@@ -153,49 +153,49 @@ pub mod external_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Description;
+        type Uri;
         type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Description = Unset;
+        type Uri = Unset;
         type Title = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Description = St::Description;
-        type Title = St::Title;
-    }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type Uri = St::Uri;
         type Description = Set<members::description>;
+        type Uri = St::Uri;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Description = St::Description;
+        type Uri = Set<members::uri>;
         type Title = St::Title;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Uri = St::Uri;
         type Description = St::Description;
+        type Uri = St::Uri;
         type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `description` field
         pub struct description(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `title` field
         pub struct title(());
     }
@@ -312,8 +312,8 @@ where
 impl<S: BosStr, St> ExternalBuilder<S, St>
 where
     St: external_state::State,
-    St::Uri: external_state::IsSet,
     St::Description: external_state::IsSet,
+    St::Uri: external_state::IsSet,
     St::Title: external_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/art_cllctv/embed/images.rs b/crates/jacquard-api/src/art_cllctv/embed/images.rs
index f7c3b677..f9d82357 100644
--- a/crates/jacquard-api/src/art_cllctv/embed/images.rs
+++ b/crates/jacquard-api/src/art_cllctv/embed/images.rs
@@ -799,50 +799,50 @@ pub mod view_image_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Thumb;
-        type Alt;
         type Fullsize;
+        type Alt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Thumb = Unset;
-        type Alt = Unset;
         type Fullsize = Unset;
+        type Alt = Unset;
     }
     ///State transition - sets the `thumb` field to Set
     pub struct SetThumb<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetThumb<St> {}
     impl<St: State> State for SetThumb<St> {
         type Thumb = Set<members::thumb>;
-        type Alt = St::Alt;
-        type Fullsize = St::Fullsize;
-    }
-    ///State transition - sets the `alt` field to Set
-    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAlt<St> {}
-    impl<St: State> State for SetAlt<St> {
-        type Thumb = St::Thumb;
-        type Alt = Set<members::alt>;
         type Fullsize = St::Fullsize;
+        type Alt = St::Alt;
     }
     ///State transition - sets the `fullsize` field to Set
     pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFullsize<St> {}
     impl<St: State> State for SetFullsize<St> {
         type Thumb = St::Thumb;
-        type Alt = St::Alt;
         type Fullsize = Set<members::fullsize>;
+        type Alt = St::Alt;
+    }
+    ///State transition - sets the `alt` field to Set
+    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAlt<St> {}
+    impl<St: State> State for SetAlt<St> {
+        type Thumb = St::Thumb;
+        type Fullsize = St::Fullsize;
+        type Alt = Set<members::alt>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `thumb` field
         pub struct thumb(());
-        ///Marker type for the `alt` field
-        pub struct alt(());
         ///Marker type for the `fullsize` field
         pub struct fullsize(());
+        ///Marker type for the `alt` field
+        pub struct alt(());
     }
 }
 
@@ -964,8 +964,8 @@ impl<S: BosStr, St> ViewImageBuilder<S, St>
 where
     St: view_image_state::State,
     St::Thumb: view_image_state::IsSet,
-    St::Alt: view_image_state::IsSet,
     St::Fullsize: view_image_state::IsSet,
+    St::Alt: view_image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewImage<S> {
diff --git a/crates/jacquard-api/src/art_cllctv/feed/pin.rs b/crates/jacquard-api/src/art_cllctv/feed/pin.rs
index 0cb70b92..a7a26388 100644
--- a/crates/jacquard-api/src/art_cllctv/feed/pin.rs
+++ b/crates/jacquard-api/src/art_cllctv/feed/pin.rs
@@ -112,37 +112,37 @@ pub mod pin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -212,8 +212,8 @@ where
 impl<S: BosStr, St> PinBuilder<S, St>
 where
     St: pin_state::State,
-    St::CreatedAt: pin_state::IsSet,
     St::Subject: pin_state::IsSet,
+    St::CreatedAt: pin_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Pin<S> {
diff --git a/crates/jacquard-api/src/at_inlay/component.rs b/crates/jacquard-api/src/at_inlay/component.rs
index c82fc571..983c8ab5 100644
--- a/crates/jacquard-api/src/at_inlay/component.rs
+++ b/crates/jacquard-api/src/at_inlay/component.rs
@@ -1293,37 +1293,37 @@ pub mod view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Prop;
         type Accepts;
+        type Prop;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Prop = Unset;
         type Accepts = Unset;
-    }
-    ///State transition - sets the `prop` field to Set
-    pub struct SetProp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetProp<St> {}
-    impl<St: State> State for SetProp<St> {
-        type Prop = Set<members::prop>;
-        type Accepts = St::Accepts;
+        type Prop = Unset;
     }
     ///State transition - sets the `accepts` field to Set
     pub struct SetAccepts<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAccepts<St> {}
     impl<St: State> State for SetAccepts<St> {
-        type Prop = St::Prop;
         type Accepts = Set<members::accepts>;
+        type Prop = St::Prop;
+    }
+    ///State transition - sets the `prop` field to Set
+    pub struct SetProp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetProp<St> {}
+    impl<St: State> State for SetProp<St> {
+        type Accepts = St::Accepts;
+        type Prop = Set<members::prop>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `prop` field
-        pub struct prop(());
         ///Marker type for the `accepts` field
         pub struct accepts(());
+        ///Marker type for the `prop` field
+        pub struct prop(());
     }
 }
 
@@ -1393,8 +1393,8 @@ where
 impl<S: BosStr, St> ViewBuilder<S, St>
 where
     St: view_state::State,
-    St::Prop: view_state::IsSet,
     St::Accepts: view_state::IsSet,
+    St::Prop: view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> View<S> {
diff --git a/crates/jacquard-api/src/at_inlay/pack.rs b/crates/jacquard-api/src/at_inlay/pack.rs
index a7bc299c..0357daae 100644
--- a/crates/jacquard-api/src/at_inlay/pack.rs
+++ b/crates/jacquard-api/src/at_inlay/pack.rs
@@ -155,37 +155,37 @@ pub mod export_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Component;
         type Type;
+        type Component;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Component = Unset;
         type Type = Unset;
-    }
-    ///State transition - sets the `component` field to Set
-    pub struct SetComponent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetComponent<St> {}
-    impl<St: State> State for SetComponent<St> {
-        type Component = Set<members::component>;
-        type Type = St::Type;
+        type Component = Unset;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type Component = St::Component;
         type Type = Set<members::r#type>;
+        type Component = St::Component;
+    }
+    ///State transition - sets the `component` field to Set
+    pub struct SetComponent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetComponent<St> {}
+    impl<St: State> State for SetComponent<St> {
+        type Type = St::Type;
+        type Component = Set<members::component>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `component` field
-        pub struct component(());
         ///Marker type for the `type` field
         pub struct r#type(());
+        ///Marker type for the `component` field
+        pub struct component(());
     }
 }
 
@@ -255,8 +255,8 @@ where
 impl<S: BosStr, St> ExportBuilder<S, St>
 where
     St: export_state::State,
-    St::Component: export_state::IsSet,
     St::Type: export_state::IsSet,
+    St::Component: export_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Export<S> {
diff --git a/crates/jacquard-api/src/at_margin/annotation.rs b/crates/jacquard-api/src/at_margin/annotation.rs
index b89e298d..937b015a 100644
--- a/crates/jacquard-api/src/at_margin/annotation.rs
+++ b/crates/jacquard-api/src/at_margin/annotation.rs
@@ -1587,37 +1587,37 @@ pub mod range_selector_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type EndSelector;
         type StartSelector;
+        type EndSelector;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type EndSelector = Unset;
         type StartSelector = Unset;
-    }
-    ///State transition - sets the `end_selector` field to Set
-    pub struct SetEndSelector<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEndSelector<St> {}
-    impl<St: State> State for SetEndSelector<St> {
-        type EndSelector = Set<members::end_selector>;
-        type StartSelector = St::StartSelector;
+        type EndSelector = Unset;
     }
     ///State transition - sets the `start_selector` field to Set
     pub struct SetStartSelector<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStartSelector<St> {}
     impl<St: State> State for SetStartSelector<St> {
-        type EndSelector = St::EndSelector;
         type StartSelector = Set<members::start_selector>;
+        type EndSelector = St::EndSelector;
+    }
+    ///State transition - sets the `end_selector` field to Set
+    pub struct SetEndSelector<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEndSelector<St> {}
+    impl<St: State> State for SetEndSelector<St> {
+        type StartSelector = St::StartSelector;
+        type EndSelector = Set<members::end_selector>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `end_selector` field
-        pub struct end_selector(());
         ///Marker type for the `start_selector` field
         pub struct start_selector(());
+        ///Marker type for the `end_selector` field
+        pub struct end_selector(());
     }
 }
 
@@ -1704,8 +1704,8 @@ impl<S: BosStr, St: range_selector_state::State> RangeSelectorBuilder<S, St> {
 impl<S: BosStr, St> RangeSelectorBuilder<S, St>
 where
     St: range_selector_state::State,
-    St::EndSelector: range_selector_state::IsSet,
     St::StartSelector: range_selector_state::IsSet,
+    St::EndSelector: range_selector_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RangeSelector<S> {
@@ -1903,37 +1903,37 @@ pub mod text_position_selector_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type End;
         type Start;
+        type End;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type End = Unset;
         type Start = Unset;
-    }
-    ///State transition - sets the `end` field to Set
-    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEnd<St> {}
-    impl<St: State> State for SetEnd<St> {
-        type End = Set<members::end>;
-        type Start = St::Start;
+        type End = Unset;
     }
     ///State transition - sets the `start` field to Set
     pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStart<St> {}
     impl<St: State> State for SetStart<St> {
-        type End = St::End;
         type Start = Set<members::start>;
+        type End = St::End;
+    }
+    ///State transition - sets the `end` field to Set
+    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEnd<St> {}
+    impl<St: State> State for SetEnd<St> {
+        type Start = St::Start;
+        type End = Set<members::end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `end` field
-        pub struct end(());
         ///Marker type for the `start` field
         pub struct start(());
+        ///Marker type for the `end` field
+        pub struct end(());
     }
 }
 
@@ -2022,8 +2022,8 @@ impl<
 impl<S: BosStr, St> TextPositionSelectorBuilder<S, St>
 where
     St: text_position_selector_state::State,
-    St::End: text_position_selector_state::IsSet,
     St::Start: text_position_selector_state::IsSet,
+    St::End: text_position_selector_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TextPositionSelector<S> {
diff --git a/crates/jacquard-api/src/at_margin/apikey.rs b/crates/jacquard-api/src/at_margin/apikey.rs
index d3caf73b..ac6abdd3 100644
--- a/crates/jacquard-api/src/at_margin/apikey.rs
+++ b/crates/jacquard-api/src/at_margin/apikey.rs
@@ -126,49 +126,49 @@ pub mod apikey_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type KeyHash;
+        type CreatedAt;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type KeyHash = Unset;
+        type CreatedAt = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type KeyHash = St::KeyHash;
-        type Name = St::Name;
-    }
     ///State transition - sets the `key_hash` field to Set
     pub struct SetKeyHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKeyHash<St> {}
     impl<St: State> State for SetKeyHash<St> {
-        type CreatedAt = St::CreatedAt;
         type KeyHash = Set<members::key_hash>;
+        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type KeyHash = St::KeyHash;
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type KeyHash = St::KeyHash;
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `key_hash` field
         pub struct key_hash(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -259,8 +259,8 @@ where
 impl<S: BosStr, St> ApikeyBuilder<S, St>
 where
     St: apikey_state::State,
-    St::CreatedAt: apikey_state::IsSet,
     St::KeyHash: apikey_state::IsSet,
+    St::CreatedAt: apikey_state::IsSet,
     St::Name: apikey_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/at_margin/collection.rs b/crates/jacquard-api/src/at_margin/collection.rs
index 783a5864..ae9ee95c 100644
--- a/crates/jacquard-api/src/at_margin/collection.rs
+++ b/crates/jacquard-api/src/at_margin/collection.rs
@@ -187,37 +187,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -313,8 +313,8 @@ where
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::CreatedAt: collection_state::IsSet,
     St::Name: collection_state::IsSet,
+    St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/at_margin/reply.rs b/crates/jacquard-api/src/at_margin/reply.rs
index 20db2bc8..d0863b89 100644
--- a/crates/jacquard-api/src/at_margin/reply.rs
+++ b/crates/jacquard-api/src/at_margin/reply.rs
@@ -176,65 +176,65 @@ pub mod reply_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Parent;
         type Root;
         type CreatedAt;
-        type Parent;
         type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Parent = Unset;
         type Root = Unset;
         type CreatedAt = Unset;
-        type Parent = Unset;
         type Text = Unset;
     }
+    ///State transition - sets the `parent` field to Set
+    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetParent<St> {}
+    impl<St: State> State for SetParent<St> {
+        type Parent = Set<members::parent>;
+        type Root = St::Root;
+        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+    }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
+        type Parent = St::Parent;
         type Root = Set<members::root>;
         type CreatedAt = St::CreatedAt;
-        type Parent = St::Parent;
         type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Root = St::Root;
-        type CreatedAt = Set<members::created_at>;
         type Parent = St::Parent;
-        type Text = St::Text;
-    }
-    ///State transition - sets the `parent` field to Set
-    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetParent<St> {}
-    impl<St: State> State for SetParent<St> {
         type Root = St::Root;
-        type CreatedAt = St::CreatedAt;
-        type Parent = Set<members::parent>;
+        type CreatedAt = Set<members::created_at>;
         type Text = St::Text;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
+        type Parent = St::Parent;
         type Root = St::Root;
         type CreatedAt = St::CreatedAt;
-        type Parent = St::Parent;
         type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `parent` field
+        pub struct parent(());
         ///Marker type for the `root` field
         pub struct root(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `parent` field
-        pub struct parent(());
         ///Marker type for the `text` field
         pub struct text(());
     }
@@ -363,9 +363,9 @@ where
 impl<S: BosStr, St> ReplyBuilder<S, St>
 where
     St: reply_state::State,
+    St::Parent: reply_state::IsSet,
     St::Root: reply_state::IsSet,
     St::CreatedAt: reply_state::IsSet,
-    St::Parent: reply_state::IsSet,
     St::Text: reply_state::IsSet,
 {
     /// Build the final struct.
@@ -515,37 +515,37 @@ pub mod reply_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Cid;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
+        type Uri = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
         type Cid = Set<members::cid>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -615,8 +615,8 @@ where
 impl<S: BosStr, St> ReplyRefBuilder<S, St>
 where
     St: reply_ref_state::State,
-    St::Uri: reply_ref_state::IsSet,
     St::Cid: reply_ref_state::IsSet,
+    St::Uri: reply_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReplyRef<S> {
diff --git a/crates/jacquard-api/src/at_podping/records/podping.rs b/crates/jacquard-api/src/at_podping/records/podping.rs
index 54a6f7ec..3bbbdd13 100644
--- a/crates/jacquard-api/src/at_podping/records/podping.rs
+++ b/crates/jacquard-api/src/at_podping/records/podping.rs
@@ -126,83 +126,83 @@ pub mod podping_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Iris;
-        type Version;
         type Medium;
+        type Version;
         type Reason;
+        type Iris;
         type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Iris = Unset;
-        type Version = Unset;
         type Medium = Unset;
+        type Version = Unset;
         type Reason = Unset;
+        type Iris = Unset;
         type Timestamp = Unset;
     }
-    ///State transition - sets the `iris` field to Set
-    pub struct SetIris<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIris<St> {}
-    impl<St: State> State for SetIris<St> {
-        type Iris = Set<members::iris>;
+    ///State transition - sets the `medium` field to Set
+    pub struct SetMedium<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMedium<St> {}
+    impl<St: State> State for SetMedium<St> {
+        type Medium = Set<members::medium>;
         type Version = St::Version;
-        type Medium = St::Medium;
         type Reason = St::Reason;
+        type Iris = St::Iris;
         type Timestamp = St::Timestamp;
     }
     ///State transition - sets the `version` field to Set
     pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVersion<St> {}
     impl<St: State> State for SetVersion<St> {
-        type Iris = St::Iris;
-        type Version = Set<members::version>;
         type Medium = St::Medium;
+        type Version = Set<members::version>;
         type Reason = St::Reason;
-        type Timestamp = St::Timestamp;
-    }
-    ///State transition - sets the `medium` field to Set
-    pub struct SetMedium<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMedium<St> {}
-    impl<St: State> State for SetMedium<St> {
         type Iris = St::Iris;
-        type Version = St::Version;
-        type Medium = Set<members::medium>;
-        type Reason = St::Reason;
         type Timestamp = St::Timestamp;
     }
     ///State transition - sets the `reason` field to Set
     pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReason<St> {}
     impl<St: State> State for SetReason<St> {
-        type Iris = St::Iris;
-        type Version = St::Version;
         type Medium = St::Medium;
+        type Version = St::Version;
         type Reason = Set<members::reason>;
+        type Iris = St::Iris;
+        type Timestamp = St::Timestamp;
+    }
+    ///State transition - sets the `iris` field to Set
+    pub struct SetIris<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIris<St> {}
+    impl<St: State> State for SetIris<St> {
+        type Medium = St::Medium;
+        type Version = St::Version;
+        type Reason = St::Reason;
+        type Iris = Set<members::iris>;
         type Timestamp = St::Timestamp;
     }
     ///State transition - sets the `timestamp` field to Set
     pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTimestamp<St> {}
     impl<St: State> State for SetTimestamp<St> {
-        type Iris = St::Iris;
-        type Version = St::Version;
         type Medium = St::Medium;
+        type Version = St::Version;
         type Reason = St::Reason;
+        type Iris = St::Iris;
         type Timestamp = Set<members::timestamp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `iris` field
-        pub struct iris(());
-        ///Marker type for the `version` field
-        pub struct version(());
         ///Marker type for the `medium` field
         pub struct medium(());
+        ///Marker type for the `version` field
+        pub struct version(());
         ///Marker type for the `reason` field
         pub struct reason(());
+        ///Marker type for the `iris` field
+        pub struct iris(());
         ///Marker type for the `timestamp` field
         pub struct timestamp(());
     }
@@ -365,10 +365,10 @@ where
 impl<S: BosStr, St> PodpingBuilder<S, St>
 where
     St: podping_state::State,
-    St::Iris: podping_state::IsSet,
-    St::Version: podping_state::IsSet,
     St::Medium: podping_state::IsSet,
+    St::Version: podping_state::IsSet,
     St::Reason: podping_state::IsSet,
+    St::Iris: podping_state::IsSet,
     St::Timestamp: podping_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/at_podping/records/startup.rs b/crates/jacquard-api/src/at_podping/records/startup.rs
index a21f2d58..f3dc3f64 100644
--- a/crates/jacquard-api/src/at_podping/records/startup.rs
+++ b/crates/jacquard-api/src/at_podping/records/startup.rs
@@ -140,51 +140,51 @@ pub mod startup_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Timestamp;
         type ServerAccount;
         type Message;
-        type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Timestamp = Unset;
         type ServerAccount = Unset;
         type Message = Unset;
-        type Timestamp = Unset;
+    }
+    ///State transition - sets the `timestamp` field to Set
+    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
+    impl<St: State> State for SetTimestamp<St> {
+        type Timestamp = Set<members::timestamp>;
+        type ServerAccount = St::ServerAccount;
+        type Message = St::Message;
     }
     ///State transition - sets the `server_account` field to Set
     pub struct SetServerAccount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetServerAccount<St> {}
     impl<St: State> State for SetServerAccount<St> {
+        type Timestamp = St::Timestamp;
         type ServerAccount = Set<members::server_account>;
         type Message = St::Message;
-        type Timestamp = St::Timestamp;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type ServerAccount = St::ServerAccount;
-        type Message = Set<members::message>;
         type Timestamp = St::Timestamp;
-    }
-    ///State transition - sets the `timestamp` field to Set
-    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
-    impl<St: State> State for SetTimestamp<St> {
         type ServerAccount = St::ServerAccount;
-        type Message = St::Message;
-        type Timestamp = Set<members::timestamp>;
+        type Message = Set<members::message>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `timestamp` field
+        pub struct timestamp(());
         ///Marker type for the `server_account` field
         pub struct server_account(());
         ///Marker type for the `message` field
         pub struct message(());
-        ///Marker type for the `timestamp` field
-        pub struct timestamp(());
     }
 }
 
@@ -389,9 +389,9 @@ impl<S: BosStr, St: startup_state::State> StartupBuilder<S, St> {
 impl<S: BosStr, St> StartupBuilder<S, St>
 where
     St: startup_state::State,
+    St::Timestamp: startup_state::IsSet,
     St::ServerAccount: startup_state::IsSet,
     St::Message: startup_state::IsSet,
-    St::Timestamp: startup_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Startup<S> {
diff --git a/crates/jacquard-api/src/at_unthread/document/put_draft.rs b/crates/jacquard-api/src/at_unthread/document/put_draft.rs
index d5a813cd..e843be78 100644
--- a/crates/jacquard-api/src/at_unthread/document/put_draft.rs
+++ b/crates/jacquard-api/src/at_unthread/document/put_draft.rs
@@ -154,67 +154,67 @@ pub mod draft_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Content;
+        type UpdatedAt;
         type Tid;
         type CreatedAt;
-        type UpdatedAt;
-        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Content = Unset;
+        type UpdatedAt = Unset;
         type Tid = Unset;
         type CreatedAt = Unset;
-        type UpdatedAt = Unset;
-        type Content = Unset;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Content = Set<members::content>;
+        type UpdatedAt = St::UpdatedAt;
+        type Tid = St::Tid;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type Content = St::Content;
+        type UpdatedAt = Set<members::updated_at>;
+        type Tid = St::Tid;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `tid` field to Set
     pub struct SetTid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTid<St> {}
     impl<St: State> State for SetTid<St> {
+        type Content = St::Content;
+        type UpdatedAt = St::UpdatedAt;
         type Tid = Set<members::tid>;
         type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
-        type Content = St::Content;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Tid = St::Tid;
-        type CreatedAt = Set<members::created_at>;
-        type UpdatedAt = St::UpdatedAt;
-        type Content = St::Content;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type Tid = St::Tid;
-        type CreatedAt = St::CreatedAt;
-        type UpdatedAt = Set<members::updated_at>;
         type Content = St::Content;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Tid = St::Tid;
-        type CreatedAt = St::CreatedAt;
         type UpdatedAt = St::UpdatedAt;
-        type Content = Set<members::content>;
+        type Tid = St::Tid;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `content` field
+        pub struct content(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
         ///Marker type for the `tid` field
         pub struct tid(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
-        ///Marker type for the `content` field
-        pub struct content(());
     }
 }
 
@@ -322,10 +322,10 @@ where
 impl<S: BosStr, St> DraftViewBuilder<S, St>
 where
     St: draft_view_state::State,
+    St::Content: draft_view_state::IsSet,
+    St::UpdatedAt: draft_view_state::IsSet,
     St::Tid: draft_view_state::IsSet,
     St::CreatedAt: draft_view_state::IsSet,
-    St::UpdatedAt: draft_view_state::IsSet,
-    St::Content: draft_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DraftView<S> {
diff --git a/crates/jacquard-api/src/at_youandme/connection.rs b/crates/jacquard-api/src/at_youandme/connection.rs
index bf3feb82..4807e053 100644
--- a/crates/jacquard-api/src/at_youandme/connection.rs
+++ b/crates/jacquard-api/src/at_youandme/connection.rs
@@ -113,37 +113,37 @@ pub mod connection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> ConnectionBuilder<S, St>
 where
     St: connection_state::State,
-    St::Subject: connection_state::IsSet,
     St::CreatedAt: connection_state::IsSet,
+    St::Subject: connection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Connection<S> {
diff --git a/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs b/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs
index 99865160..de800f5f 100644
--- a/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs
+++ b/crates/jacquard-api/src/beauty_cybernetic/trustcow/transaction.rs
@@ -159,66 +159,66 @@ pub mod transaction_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
+        type ServiceConsumer;
         type TransactionId;
         type ServiceProvider;
-        type ServiceConsumer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
+        type ServiceConsumer = Unset;
         type TransactionId = Unset;
         type ServiceProvider = Unset;
-        type ServiceConsumer = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
+        type ServiceConsumer = St::ServiceConsumer;
+        type TransactionId = St::TransactionId;
+        type ServiceProvider = St::ServiceProvider;
+    }
+    ///State transition - sets the `service_consumer` field to Set
+    pub struct SetServiceConsumer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetServiceConsumer<St> {}
+    impl<St: State> State for SetServiceConsumer<St> {
+        type CreatedAt = St::CreatedAt;
+        type ServiceConsumer = Set<members::service_consumer>;
         type TransactionId = St::TransactionId;
         type ServiceProvider = St::ServiceProvider;
-        type ServiceConsumer = St::ServiceConsumer;
     }
     ///State transition - sets the `transaction_id` field to Set
     pub struct SetTransactionId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTransactionId<St> {}
     impl<St: State> State for SetTransactionId<St> {
         type CreatedAt = St::CreatedAt;
+        type ServiceConsumer = St::ServiceConsumer;
         type TransactionId = Set<members::transaction_id>;
         type ServiceProvider = St::ServiceProvider;
-        type ServiceConsumer = St::ServiceConsumer;
     }
     ///State transition - sets the `service_provider` field to Set
     pub struct SetServiceProvider<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetServiceProvider<St> {}
     impl<St: State> State for SetServiceProvider<St> {
         type CreatedAt = St::CreatedAt;
-        type TransactionId = St::TransactionId;
-        type ServiceProvider = Set<members::service_provider>;
         type ServiceConsumer = St::ServiceConsumer;
-    }
-    ///State transition - sets the `service_consumer` field to Set
-    pub struct SetServiceConsumer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetServiceConsumer<St> {}
-    impl<St: State> State for SetServiceConsumer<St> {
-        type CreatedAt = St::CreatedAt;
         type TransactionId = St::TransactionId;
-        type ServiceProvider = St::ServiceProvider;
-        type ServiceConsumer = Set<members::service_consumer>;
+        type ServiceProvider = Set<members::service_provider>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `service_consumer` field
+        pub struct service_consumer(());
         ///Marker type for the `transaction_id` field
         pub struct transaction_id(());
         ///Marker type for the `service_provider` field
         pub struct service_provider(());
-        ///Marker type for the `service_consumer` field
-        pub struct service_consumer(());
     }
 }
 
@@ -374,9 +374,9 @@ impl<S: BosStr, St> TransactionBuilder<S, St>
 where
     St: transaction_state::State,
     St::CreatedAt: transaction_state::IsSet,
+    St::ServiceConsumer: transaction_state::IsSet,
     St::TransactionId: transaction_state::IsSet,
     St::ServiceProvider: transaction_state::IsSet,
-    St::ServiceConsumer: transaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Transaction<S> {
diff --git a/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs b/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs
index 1b696cf6..e3867cd7 100644
--- a/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs
+++ b/crates/jacquard-api/src/beauty_cybernetic/trustcow/warrant.rs
@@ -314,37 +314,37 @@ pub mod warrant_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -479,8 +479,8 @@ impl<S: BosStr, St: warrant_state::State> WarrantBuilder<S, St> {
 impl<S: BosStr, St> WarrantBuilder<S, St>
 where
     St: warrant_state::State,
-    St::Subject: warrant_state::IsSet,
     St::CreatedAt: warrant_state::IsSet,
+    St::Subject: warrant_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Warrant<S> {
diff --git a/crates/jacquard-api/src/blog_pckt/block/image.rs b/crates/jacquard-api/src/blog_pckt/block/image.rs
index 9415409a..54a68b83 100644
--- a/crates/jacquard-api/src/blog_pckt/block/image.rs
+++ b/crates/jacquard-api/src/blog_pckt/block/image.rs
@@ -242,37 +242,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -342,8 +342,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Width: aspect_ratio_state::IsSet,
     St::Height: aspect_ratio_state::IsSet,
+    St::Width: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
diff --git a/crates/jacquard-api/src/blog_pckt/block/mention.rs b/crates/jacquard-api/src/blog_pckt/block/mention.rs
index d9fbe1a6..82a9e9a4 100644
--- a/crates/jacquard-api/src/blog_pckt/block/mention.rs
+++ b/crates/jacquard-api/src/blog_pckt/block/mention.rs
@@ -72,37 +72,37 @@ pub mod mention_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Did;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Did = St::Did;
+        type Handle = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Handle = St::Handle;
         type Did = Set<members::did>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -172,8 +172,8 @@ where
 impl<S: BosStr, St> MentionBuilder<S, St>
 where
     St: mention_state::State,
-    St::Handle: mention_state::IsSet,
     St::Did: mention_state::IsSet,
+    St::Handle: mention_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Mention<S> {
diff --git a/crates/jacquard-api/src/blog_pckt/block/task_item.rs b/crates/jacquard-api/src/blog_pckt/block/task_item.rs
index af8fb633..1541dfa3 100644
--- a/crates/jacquard-api/src/blog_pckt/block/task_item.rs
+++ b/crates/jacquard-api/src/blog_pckt/block/task_item.rs
@@ -61,37 +61,37 @@ pub mod task_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Checked;
         type Content;
+        type Checked;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Checked = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `checked` field to Set
-    pub struct SetChecked<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChecked<St> {}
-    impl<St: State> State for SetChecked<St> {
-        type Checked = Set<members::checked>;
-        type Content = St::Content;
+        type Checked = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Checked = St::Checked;
         type Content = Set<members::content>;
+        type Checked = St::Checked;
+    }
+    ///State transition - sets the `checked` field to Set
+    pub struct SetChecked<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChecked<St> {}
+    impl<St: State> State for SetChecked<St> {
+        type Content = St::Content;
+        type Checked = Set<members::checked>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `checked` field
-        pub struct checked(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `checked` field
+        pub struct checked(());
     }
 }
 
@@ -161,8 +161,8 @@ where
 impl<S: BosStr, St> TaskItemBuilder<S, St>
 where
     St: task_item_state::State,
-    St::Checked: task_item_state::IsSet,
     St::Content: task_item_state::IsSet,
+    St::Checked: task_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TaskItem<S> {
diff --git a/crates/jacquard-api/src/blog_pckt/post.rs b/crates/jacquard-api/src/blog_pckt/post.rs
index 2da0bff7..a8f66aa6 100644
--- a/crates/jacquard-api/src/blog_pckt/post.rs
+++ b/crates/jacquard-api/src/blog_pckt/post.rs
@@ -153,67 +153,67 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Blocks;
-        type Url;
         type Blog;
         type Title;
+        type Url;
+        type Blocks;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Blocks = Unset;
-        type Url = Unset;
         type Blog = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `blocks` field to Set
-    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlocks<St> {}
-    impl<St: State> State for SetBlocks<St> {
-        type Blocks = Set<members::blocks>;
-        type Url = St::Url;
-        type Blog = St::Blog;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Blocks = St::Blocks;
-        type Url = Set<members::url>;
-        type Blog = St::Blog;
-        type Title = St::Title;
+        type Url = Unset;
+        type Blocks = Unset;
     }
     ///State transition - sets the `blog` field to Set
     pub struct SetBlog<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlog<St> {}
     impl<St: State> State for SetBlog<St> {
-        type Blocks = St::Blocks;
-        type Url = St::Url;
         type Blog = Set<members::blog>;
         type Title = St::Title;
+        type Url = St::Url;
+        type Blocks = St::Blocks;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Blocks = St::Blocks;
-        type Url = St::Url;
         type Blog = St::Blog;
         type Title = Set<members::title>;
+        type Url = St::Url;
+        type Blocks = St::Blocks;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Blog = St::Blog;
+        type Title = St::Title;
+        type Url = Set<members::url>;
+        type Blocks = St::Blocks;
+    }
+    ///State transition - sets the `blocks` field to Set
+    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlocks<St> {}
+    impl<St: State> State for SetBlocks<St> {
+        type Blog = St::Blog;
+        type Title = St::Title;
+        type Url = St::Url;
+        type Blocks = Set<members::blocks>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `blocks` field
-        pub struct blocks(());
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `blog` field
         pub struct blog(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `url` field
+        pub struct url(());
+        ///Marker type for the `blocks` field
+        pub struct blocks(());
     }
 }
 
@@ -410,10 +410,10 @@ where
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
-    St::Blocks: post_state::IsSet,
-    St::Url: post_state::IsSet,
     St::Blog: post_state::IsSet,
     St::Title: post_state::IsSet,
+    St::Url: post_state::IsSet,
+    St::Blocks: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/blog_pckt/richtext/facet.rs b/crates/jacquard-api/src/blog_pckt/richtext/facet.rs
index e832f36b..98f518a6 100644
--- a/crates/jacquard-api/src/blog_pckt/richtext/facet.rs
+++ b/crates/jacquard-api/src/blog_pckt/richtext/facet.rs
@@ -740,37 +740,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteEnd;
         type ByteStart;
+        type ByteEnd;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteEnd = Unset;
         type ByteStart = Unset;
-    }
-    ///State transition - sets the `byte_end` field to Set
-    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
-    impl<St: State> State for SetByteEnd<St> {
-        type ByteEnd = Set<members::byte_end>;
-        type ByteStart = St::ByteStart;
+        type ByteEnd = Unset;
     }
     ///State transition - sets the `byte_start` field to Set
     pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteStart<St> {}
     impl<St: State> State for SetByteStart<St> {
-        type ByteEnd = St::ByteEnd;
         type ByteStart = Set<members::byte_start>;
+        type ByteEnd = St::ByteEnd;
+    }
+    ///State transition - sets the `byte_end` field to Set
+    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
+    impl<St: State> State for SetByteEnd<St> {
+        type ByteStart = St::ByteStart;
+        type ByteEnd = Set<members::byte_end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_end` field
-        pub struct byte_end(());
         ///Marker type for the `byte_start` field
         pub struct byte_start(());
+        ///Marker type for the `byte_end` field
+        pub struct byte_end(());
     }
 }
 
@@ -840,8 +840,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteEnd: byte_slice_state::IsSet,
     St::ByteStart: byte_slice_state::IsSet,
+    St::ByteEnd: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
@@ -974,37 +974,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Features;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Features = St::Features;
+        type Index = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Index = St::Index;
         type Features = Set<members::features>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Features = St::Features;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -1074,8 +1074,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Index: facet_state::IsSet,
     St::Features: facet_state::IsSet,
+    St::Index: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/blue__2048.rs b/crates/jacquard-api/src/blue__2048.rs
index 2cf68856..b6fde637 100644
--- a/crates/jacquard-api/src/blue__2048.rs
+++ b/crates/jacquard-api/src/blue__2048.rs
@@ -75,65 +75,65 @@ pub mod sync_status_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Hash;
         type UpdatedAt;
+        type CreatedAt;
         type SyncedWithAtRepo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Hash = Unset;
         type UpdatedAt = Unset;
+        type CreatedAt = Unset;
         type SyncedWithAtRepo = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Hash = St::Hash;
-        type UpdatedAt = St::UpdatedAt;
-        type SyncedWithAtRepo = St::SyncedWithAtRepo;
-    }
     ///State transition - sets the `hash` field to Set
     pub struct SetHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHash<St> {}
     impl<St: State> State for SetHash<St> {
-        type CreatedAt = St::CreatedAt;
         type Hash = Set<members::hash>;
         type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = St::CreatedAt;
         type SyncedWithAtRepo = St::SyncedWithAtRepo;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
-        type CreatedAt = St::CreatedAt;
         type Hash = St::Hash;
         type UpdatedAt = Set<members::updated_at>;
+        type CreatedAt = St::CreatedAt;
+        type SyncedWithAtRepo = St::SyncedWithAtRepo;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Hash = St::Hash;
+        type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = Set<members::created_at>;
         type SyncedWithAtRepo = St::SyncedWithAtRepo;
     }
     ///State transition - sets the `synced_with_at_repo` field to Set
     pub struct SetSyncedWithAtRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSyncedWithAtRepo<St> {}
     impl<St: State> State for SetSyncedWithAtRepo<St> {
-        type CreatedAt = St::CreatedAt;
         type Hash = St::Hash;
         type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = St::CreatedAt;
         type SyncedWithAtRepo = Set<members::synced_with_at_repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `hash` field
         pub struct hash(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `synced_with_at_repo` field
         pub struct synced_with_at_repo(());
     }
@@ -243,9 +243,9 @@ where
 impl<S: BosStr, St> SyncStatusBuilder<S, St>
 where
     St: sync_status_state::State,
-    St::CreatedAt: sync_status_state::IsSet,
     St::Hash: sync_status_state::IsSet,
     St::UpdatedAt: sync_status_state::IsSet,
+    St::CreatedAt: sync_status_state::IsSet,
     St::SyncedWithAtRepo: sync_status_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/blue__2048/game.rs b/crates/jacquard-api/src/blue__2048/game.rs
index 01c207c1..593034e7 100644
--- a/crates/jacquard-api/src/blue__2048/game.rs
+++ b/crates/jacquard-api/src/blue__2048/game.rs
@@ -137,105 +137,105 @@ pub mod game_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type SeededRecording;
         type CurrentScore;
-        type Won;
-        type SyncStatus;
+        type SeededRecording;
         type Completed;
+        type CreatedAt;
+        type SyncStatus;
+        type Won;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type SeededRecording = Unset;
         type CurrentScore = Unset;
-        type Won = Unset;
-        type SyncStatus = Unset;
+        type SeededRecording = Unset;
         type Completed = Unset;
+        type CreatedAt = Unset;
+        type SyncStatus = Unset;
+        type Won = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `current_score` field to Set
+    pub struct SetCurrentScore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCurrentScore<St> {}
+    impl<St: State> State for SetCurrentScore<St> {
+        type CurrentScore = Set<members::current_score>;
         type SeededRecording = St::SeededRecording;
-        type CurrentScore = St::CurrentScore;
-        type Won = St::Won;
-        type SyncStatus = St::SyncStatus;
         type Completed = St::Completed;
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type Won = St::Won;
     }
     ///State transition - sets the `seeded_recording` field to Set
     pub struct SetSeededRecording<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeededRecording<St> {}
     impl<St: State> State for SetSeededRecording<St> {
-        type CreatedAt = St::CreatedAt;
-        type SeededRecording = Set<members::seeded_recording>;
         type CurrentScore = St::CurrentScore;
-        type Won = St::Won;
-        type SyncStatus = St::SyncStatus;
+        type SeededRecording = Set<members::seeded_recording>;
         type Completed = St::Completed;
-    }
-    ///State transition - sets the `current_score` field to Set
-    pub struct SetCurrentScore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCurrentScore<St> {}
-    impl<St: State> State for SetCurrentScore<St> {
         type CreatedAt = St::CreatedAt;
-        type SeededRecording = St::SeededRecording;
-        type CurrentScore = Set<members::current_score>;
-        type Won = St::Won;
         type SyncStatus = St::SyncStatus;
-        type Completed = St::Completed;
+        type Won = St::Won;
     }
-    ///State transition - sets the `won` field to Set
-    pub struct SetWon<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWon<St> {}
-    impl<St: State> State for SetWon<St> {
-        type CreatedAt = St::CreatedAt;
-        type SeededRecording = St::SeededRecording;
+    ///State transition - sets the `completed` field to Set
+    pub struct SetCompleted<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCompleted<St> {}
+    impl<St: State> State for SetCompleted<St> {
         type CurrentScore = St::CurrentScore;
-        type Won = Set<members::won>;
+        type SeededRecording = St::SeededRecording;
+        type Completed = Set<members::completed>;
+        type CreatedAt = St::CreatedAt;
         type SyncStatus = St::SyncStatus;
+        type Won = St::Won;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CurrentScore = St::CurrentScore;
+        type SeededRecording = St::SeededRecording;
         type Completed = St::Completed;
+        type CreatedAt = Set<members::created_at>;
+        type SyncStatus = St::SyncStatus;
+        type Won = St::Won;
     }
     ///State transition - sets the `sync_status` field to Set
     pub struct SetSyncStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSyncStatus<St> {}
     impl<St: State> State for SetSyncStatus<St> {
-        type CreatedAt = St::CreatedAt;
-        type SeededRecording = St::SeededRecording;
         type CurrentScore = St::CurrentScore;
-        type Won = St::Won;
-        type SyncStatus = Set<members::sync_status>;
+        type SeededRecording = St::SeededRecording;
         type Completed = St::Completed;
-    }
-    ///State transition - sets the `completed` field to Set
-    pub struct SetCompleted<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCompleted<St> {}
-    impl<St: State> State for SetCompleted<St> {
         type CreatedAt = St::CreatedAt;
-        type SeededRecording = St::SeededRecording;
-        type CurrentScore = St::CurrentScore;
+        type SyncStatus = Set<members::sync_status>;
         type Won = St::Won;
+    }
+    ///State transition - sets the `won` field to Set
+    pub struct SetWon<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWon<St> {}
+    impl<St: State> State for SetWon<St> {
+        type CurrentScore = St::CurrentScore;
+        type SeededRecording = St::SeededRecording;
+        type Completed = St::Completed;
+        type CreatedAt = St::CreatedAt;
         type SyncStatus = St::SyncStatus;
-        type Completed = Set<members::completed>;
+        type Won = Set<members::won>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `seeded_recording` field
-        pub struct seeded_recording(());
         ///Marker type for the `current_score` field
         pub struct current_score(());
-        ///Marker type for the `won` field
-        pub struct won(());
-        ///Marker type for the `sync_status` field
-        pub struct sync_status(());
+        ///Marker type for the `seeded_recording` field
+        pub struct seeded_recording(());
         ///Marker type for the `completed` field
         pub struct completed(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `sync_status` field
+        pub struct sync_status(());
+        ///Marker type for the `won` field
+        pub struct won(());
     }
 }
 
@@ -388,12 +388,12 @@ where
 impl<S: BosStr, St> GameBuilder<S, St>
 where
     St: game_state::State,
-    St::CreatedAt: game_state::IsSet,
-    St::SeededRecording: game_state::IsSet,
     St::CurrentScore: game_state::IsSet,
-    St::Won: game_state::IsSet,
-    St::SyncStatus: game_state::IsSet,
+    St::SeededRecording: game_state::IsSet,
     St::Completed: game_state::IsSet,
+    St::CreatedAt: game_state::IsSet,
+    St::SyncStatus: game_state::IsSet,
+    St::Won: game_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Game<S> {
diff --git a/crates/jacquard-api/src/blue__2048/key.rs b/crates/jacquard-api/src/blue__2048/key.rs
index 2b44a236..c5bc05ca 100644
--- a/crates/jacquard-api/src/blue__2048/key.rs
+++ b/crates/jacquard-api/src/blue__2048/key.rs
@@ -329,49 +329,49 @@ pub mod signature_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AtUri;
         type CreatedAt;
+        type AtUri;
         type Signature;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AtUri = Unset;
         type CreatedAt = Unset;
+        type AtUri = Unset;
         type Signature = Unset;
     }
-    ///State transition - sets the `at_uri` field to Set
-    pub struct SetAtUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAtUri<St> {}
-    impl<St: State> State for SetAtUri<St> {
-        type AtUri = Set<members::at_uri>;
-        type CreatedAt = St::CreatedAt;
-        type Signature = St::Signature;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type AtUri = St::AtUri;
         type CreatedAt = Set<members::created_at>;
+        type AtUri = St::AtUri;
+        type Signature = St::Signature;
+    }
+    ///State transition - sets the `at_uri` field to Set
+    pub struct SetAtUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAtUri<St> {}
+    impl<St: State> State for SetAtUri<St> {
+        type CreatedAt = St::CreatedAt;
+        type AtUri = Set<members::at_uri>;
         type Signature = St::Signature;
     }
     ///State transition - sets the `signature` field to Set
     pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignature<St> {}
     impl<St: State> State for SetSignature<St> {
-        type AtUri = St::AtUri;
         type CreatedAt = St::CreatedAt;
+        type AtUri = St::AtUri;
         type Signature = Set<members::signature>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `at_uri` field
-        pub struct at_uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `at_uri` field
+        pub struct at_uri(());
         ///Marker type for the `signature` field
         pub struct signature(());
     }
@@ -462,8 +462,8 @@ where
 impl<S: BosStr, St> SignatureRefBuilder<S, St>
 where
     St: signature_ref_state::State,
-    St::AtUri: signature_ref_state::IsSet,
     St::CreatedAt: signature_ref_state::IsSet,
+    St::AtUri: signature_ref_state::IsSet,
     St::Signature: signature_ref_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/blue__2048/key/game.rs b/crates/jacquard-api/src/blue__2048/key/game.rs
index b524ef07..84979b07 100644
--- a/crates/jacquard-api/src/blue__2048/key/game.rs
+++ b/crates/jacquard-api/src/blue__2048/key/game.rs
@@ -114,37 +114,37 @@ pub mod game_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Key;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Key = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Key = St::Key;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type CreatedAt = St::CreatedAt;
         type Key = Set<members::key>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Key = St::Key;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `key` field
         pub struct key(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> GameBuilder<S, St>
 where
     St: game_state::State,
-    St::CreatedAt: game_state::IsSet,
     St::Key: game_state::IsSet,
+    St::CreatedAt: game_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Game<S> {
diff --git a/crates/jacquard-api/src/blue__2048/player/profile.rs b/crates/jacquard-api/src/blue__2048/player/profile.rs
index 69240a9d..17dbdcb8 100644
--- a/crates/jacquard-api/src/blue__2048/player/profile.rs
+++ b/crates/jacquard-api/src/blue__2048/player/profile.rs
@@ -121,51 +121,51 @@ pub mod profile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type SyncStatus;
-        type SoloPlay;
         type CreatedAt;
+        type SoloPlay;
+        type SyncStatus;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type SyncStatus = Unset;
-        type SoloPlay = Unset;
         type CreatedAt = Unset;
+        type SoloPlay = Unset;
+        type SyncStatus = Unset;
     }
-    ///State transition - sets the `sync_status` field to Set
-    pub struct SetSyncStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSyncStatus<St> {}
-    impl<St: State> State for SetSyncStatus<St> {
-        type SyncStatus = Set<members::sync_status>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type SoloPlay = St::SoloPlay;
-        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
     }
     ///State transition - sets the `solo_play` field to Set
     pub struct SetSoloPlay<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSoloPlay<St> {}
     impl<St: State> State for SetSoloPlay<St> {
-        type SyncStatus = St::SyncStatus;
-        type SoloPlay = Set<members::solo_play>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type SoloPlay = Set<members::solo_play>;
         type SyncStatus = St::SyncStatus;
+    }
+    ///State transition - sets the `sync_status` field to Set
+    pub struct SetSyncStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSyncStatus<St> {}
+    impl<St: State> State for SetSyncStatus<St> {
+        type CreatedAt = St::CreatedAt;
         type SoloPlay = St::SoloPlay;
-        type CreatedAt = Set<members::created_at>;
+        type SyncStatus = Set<members::sync_status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `sync_status` field
-        pub struct sync_status(());
-        ///Marker type for the `solo_play` field
-        pub struct solo_play(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `solo_play` field
+        pub struct solo_play(());
+        ///Marker type for the `sync_status` field
+        pub struct sync_status(());
     }
 }
 
@@ -254,9 +254,9 @@ where
 impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
-    St::SyncStatus: profile_state::IsSet,
-    St::SoloPlay: profile_state::IsSet,
     St::CreatedAt: profile_state::IsSet,
+    St::SoloPlay: profile_state::IsSet,
+    St::SyncStatus: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
diff --git a/crates/jacquard-api/src/blue__2048/player/stats.rs b/crates/jacquard-api/src/blue__2048/player/stats.rs
index 268f91ff..71dc3f3e 100644
--- a/crates/jacquard-api/src/blue__2048/player/stats.rs
+++ b/crates/jacquard-api/src/blue__2048/player/stats.rs
@@ -163,57 +163,85 @@ pub mod stats_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AverageScore;
+        type CreatedAt;
+        type SyncStatus;
+        type HighestScore;
         type HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound;
-        type HighestScore;
         type LeastMovesToFindTwentyFortyEight;
-        type CreatedAt;
-        type SyncStatus;
-        type GamesPlayed;
+        type AverageScore;
         type TotalScore;
+        type GamesPlayed;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AverageScore = Unset;
+        type CreatedAt = Unset;
+        type SyncStatus = Unset;
+        type HighestScore = Unset;
         type HighestNumberBlock = Unset;
         type TimesTwentyFortyEightBeenFound = Unset;
-        type HighestScore = Unset;
         type LeastMovesToFindTwentyFortyEight = Unset;
-        type CreatedAt = Unset;
-        type SyncStatus = Unset;
-        type GamesPlayed = Unset;
+        type AverageScore = Unset;
         type TotalScore = Unset;
+        type GamesPlayed = Unset;
     }
-    ///State transition - sets the `average_score` field to Set
-    pub struct SetAverageScore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAverageScore<St> {}
-    impl<St: State> State for SetAverageScore<St> {
-        type AverageScore = Set<members::average_score>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
+        type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
+        type AverageScore = St::AverageScore;
+        type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
+    }
+    ///State transition - sets the `sync_status` field to Set
+    pub struct SetSyncStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSyncStatus<St> {}
+    impl<St: State> State for SetSyncStatus<St> {
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = Set<members::sync_status>;
         type HighestScore = St::HighestScore;
+        type HighestNumberBlock = St::HighestNumberBlock;
+        type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
+        type AverageScore = St::AverageScore;
+        type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
+    }
+    ///State transition - sets the `highest_score` field to Set
+    pub struct SetHighestScore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHighestScore<St> {}
+    impl<St: State> State for SetHighestScore<St> {
         type CreatedAt = St::CreatedAt;
         type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
+        type HighestScore = Set<members::highest_score>;
+        type HighestNumberBlock = St::HighestNumberBlock;
+        type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
+        type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
+        type AverageScore = St::AverageScore;
         type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
     }
     ///State transition - sets the `highest_number_block` field to Set
     pub struct SetHighestNumberBlock<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHighestNumberBlock<St> {}
     impl<St: State> State for SetHighestNumberBlock<St> {
-        type AverageScore = St::AverageScore;
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = Set<members::highest_number_block>;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
+        type AverageScore = St::AverageScore;
         type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
     }
     ///State transition - sets the `times_twenty_forty_eight_been_found` field to Set
     pub struct SetTimesTwentyFortyEightBeenFound<St: State = Empty>(
@@ -221,31 +249,17 @@ pub mod stats_state {
     );
     impl<St: State> sealed::Sealed for SetTimesTwentyFortyEightBeenFound<St> {}
     impl<St: State> State for SetTimesTwentyFortyEightBeenFound<St> {
-        type AverageScore = St::AverageScore;
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = Set<
             members::times_twenty_forty_eight_been_found,
         >;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
-        type TotalScore = St::TotalScore;
-    }
-    ///State transition - sets the `highest_score` field to Set
-    pub struct SetHighestScore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHighestScore<St> {}
-    impl<St: State> State for SetHighestScore<St> {
         type AverageScore = St::AverageScore;
-        type HighestNumberBlock = St::HighestNumberBlock;
-        type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = Set<members::highest_score>;
-        type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
         type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
     }
     ///State transition - sets the `least_moves_to_find_twenty_forty_eight` field to Set
     pub struct SetLeastMovesToFindTwentyFortyEight<St: State = Empty>(
@@ -253,95 +267,81 @@ pub mod stats_state {
     );
     impl<St: State> sealed::Sealed for SetLeastMovesToFindTwentyFortyEight<St> {}
     impl<St: State> State for SetLeastMovesToFindTwentyFortyEight<St> {
-        type AverageScore = St::AverageScore;
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = Set<
             members::least_moves_to_find_twenty_forty_eight,
         >;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
+        type AverageScore = St::AverageScore;
         type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type AverageScore = St::AverageScore;
+    ///State transition - sets the `average_score` field to Set
+    pub struct SetAverageScore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAverageScore<St> {}
+    impl<St: State> State for SetAverageScore<St> {
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = Set<members::created_at>;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
+        type AverageScore = Set<members::average_score>;
         type TotalScore = St::TotalScore;
+        type GamesPlayed = St::GamesPlayed;
     }
-    ///State transition - sets the `sync_status` field to Set
-    pub struct SetSyncStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSyncStatus<St> {}
-    impl<St: State> State for SetSyncStatus<St> {
-        type AverageScore = St::AverageScore;
+    ///State transition - sets the `total_score` field to Set
+    pub struct SetTotalScore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalScore<St> {}
+    impl<St: State> State for SetTotalScore<St> {
+        type CreatedAt = St::CreatedAt;
+        type SyncStatus = St::SyncStatus;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = Set<members::sync_status>;
+        type AverageScore = St::AverageScore;
+        type TotalScore = Set<members::total_score>;
         type GamesPlayed = St::GamesPlayed;
-        type TotalScore = St::TotalScore;
     }
     ///State transition - sets the `games_played` field to Set
     pub struct SetGamesPlayed<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGamesPlayed<St> {}
     impl<St: State> State for SetGamesPlayed<St> {
-        type AverageScore = St::AverageScore;
-        type HighestNumberBlock = St::HighestNumberBlock;
-        type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
-        type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
         type CreatedAt = St::CreatedAt;
         type SyncStatus = St::SyncStatus;
-        type GamesPlayed = Set<members::games_played>;
-        type TotalScore = St::TotalScore;
-    }
-    ///State transition - sets the `total_score` field to Set
-    pub struct SetTotalScore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalScore<St> {}
-    impl<St: State> State for SetTotalScore<St> {
-        type AverageScore = St::AverageScore;
+        type HighestScore = St::HighestScore;
         type HighestNumberBlock = St::HighestNumberBlock;
         type TimesTwentyFortyEightBeenFound = St::TimesTwentyFortyEightBeenFound;
-        type HighestScore = St::HighestScore;
         type LeastMovesToFindTwentyFortyEight = St::LeastMovesToFindTwentyFortyEight;
-        type CreatedAt = St::CreatedAt;
-        type SyncStatus = St::SyncStatus;
-        type GamesPlayed = St::GamesPlayed;
-        type TotalScore = Set<members::total_score>;
+        type AverageScore = St::AverageScore;
+        type TotalScore = St::TotalScore;
+        type GamesPlayed = Set<members::games_played>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `average_score` field
-        pub struct average_score(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `sync_status` field
+        pub struct sync_status(());
+        ///Marker type for the `highest_score` field
+        pub struct highest_score(());
         ///Marker type for the `highest_number_block` field
         pub struct highest_number_block(());
         ///Marker type for the `times_twenty_forty_eight_been_found` field
         pub struct times_twenty_forty_eight_been_found(());
-        ///Marker type for the `highest_score` field
-        pub struct highest_score(());
         ///Marker type for the `least_moves_to_find_twenty_forty_eight` field
         pub struct least_moves_to_find_twenty_forty_eight(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `sync_status` field
-        pub struct sync_status(());
-        ///Marker type for the `games_played` field
-        pub struct games_played(());
+        ///Marker type for the `average_score` field
+        pub struct average_score(());
         ///Marker type for the `total_score` field
         pub struct total_score(());
+        ///Marker type for the `games_played` field
+        pub struct games_played(());
     }
 }
 
@@ -554,15 +554,15 @@ where
 impl<S: BosStr, St> StatsBuilder<S, St>
 where
     St: stats_state::State,
-    St::AverageScore: stats_state::IsSet,
+    St::CreatedAt: stats_state::IsSet,
+    St::SyncStatus: stats_state::IsSet,
+    St::HighestScore: stats_state::IsSet,
     St::HighestNumberBlock: stats_state::IsSet,
     St::TimesTwentyFortyEightBeenFound: stats_state::IsSet,
-    St::HighestScore: stats_state::IsSet,
     St::LeastMovesToFindTwentyFortyEight: stats_state::IsSet,
-    St::CreatedAt: stats_state::IsSet,
-    St::SyncStatus: stats_state::IsSet,
-    St::GamesPlayed: stats_state::IsSet,
+    St::AverageScore: stats_state::IsSet,
     St::TotalScore: stats_state::IsSet,
+    St::GamesPlayed: stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Stats<S> {
diff --git a/crates/jacquard-api/src/blue__2048/verification.rs b/crates/jacquard-api/src/blue__2048/verification.rs
index 918d485d..6330fc80 100644
--- a/crates/jacquard-api/src/blue__2048/verification.rs
+++ b/crates/jacquard-api/src/blue__2048/verification.rs
@@ -71,85 +71,85 @@ pub mod verification_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Signature;
         type KeyRef;
-        type CreatedAt;
-        type Subject;
+        type Signature;
         type RecordRef;
+        type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Signature = Unset;
         type KeyRef = Unset;
-        type CreatedAt = Unset;
-        type Subject = Unset;
+        type Signature = Unset;
         type RecordRef = Unset;
-    }
-    ///State transition - sets the `signature` field to Set
-    pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSignature<St> {}
-    impl<St: State> State for SetSignature<St> {
-        type Signature = Set<members::signature>;
-        type KeyRef = St::KeyRef;
-        type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-        type RecordRef = St::RecordRef;
+        type Subject = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `key_ref` field to Set
     pub struct SetKeyRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKeyRef<St> {}
     impl<St: State> State for SetKeyRef<St> {
-        type Signature = St::Signature;
         type KeyRef = Set<members::key_ref>;
-        type CreatedAt = St::CreatedAt;
+        type Signature = St::Signature;
+        type RecordRef = St::RecordRef;
         type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `signature` field to Set
+    pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSignature<St> {}
+    impl<St: State> State for SetSignature<St> {
+        type KeyRef = St::KeyRef;
+        type Signature = Set<members::signature>;
         type RecordRef = St::RecordRef;
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Signature = St::Signature;
+    ///State transition - sets the `record_ref` field to Set
+    pub struct SetRecordRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecordRef<St> {}
+    impl<St: State> State for SetRecordRef<St> {
         type KeyRef = St::KeyRef;
-        type CreatedAt = Set<members::created_at>;
+        type Signature = St::Signature;
+        type RecordRef = Set<members::record_ref>;
         type Subject = St::Subject;
-        type RecordRef = St::RecordRef;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Signature = St::Signature;
         type KeyRef = St::KeyRef;
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type Signature = St::Signature;
         type RecordRef = St::RecordRef;
+        type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `record_ref` field to Set
-    pub struct SetRecordRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecordRef<St> {}
-    impl<St: State> State for SetRecordRef<St> {
-        type Signature = St::Signature;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type KeyRef = St::KeyRef;
-        type CreatedAt = St::CreatedAt;
+        type Signature = St::Signature;
+        type RecordRef = St::RecordRef;
         type Subject = St::Subject;
-        type RecordRef = Set<members::record_ref>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `signature` field
-        pub struct signature(());
         ///Marker type for the `key_ref` field
         pub struct key_ref(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
+        ///Marker type for the `signature` field
+        pub struct signature(());
         ///Marker type for the `record_ref` field
         pub struct record_ref(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -282,11 +282,11 @@ where
 impl<S: BosStr, St> VerificationRefBuilder<S, St>
 where
     St: verification_ref_state::State,
-    St::Signature: verification_ref_state::IsSet,
     St::KeyRef: verification_ref_state::IsSet,
-    St::CreatedAt: verification_ref_state::IsSet,
-    St::Subject: verification_ref_state::IsSet,
+    St::Signature: verification_ref_state::IsSet,
     St::RecordRef: verification_ref_state::IsSet,
+    St::Subject: verification_ref_state::IsSet,
+    St::CreatedAt: verification_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> VerificationRef<S> {
diff --git a/crates/jacquard-api/src/blue_atroom/room/layout.rs b/crates/jacquard-api/src/blue_atroom/room/layout.rs
index b97274de..2940ccd1 100644
--- a/crates/jacquard-api/src/blue_atroom/room/layout.rs
+++ b/crates/jacquard-api/src/blue_atroom/room/layout.rs
@@ -958,51 +958,51 @@ pub mod furnishing_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Object;
         type Rotation;
         type Position;
+        type Object;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Object = Unset;
         type Rotation = Unset;
         type Position = Unset;
-    }
-    ///State transition - sets the `object` field to Set
-    pub struct SetObject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObject<St> {}
-    impl<St: State> State for SetObject<St> {
-        type Object = Set<members::object>;
-        type Rotation = St::Rotation;
-        type Position = St::Position;
+        type Object = Unset;
     }
     ///State transition - sets the `rotation` field to Set
     pub struct SetRotation<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRotation<St> {}
     impl<St: State> State for SetRotation<St> {
-        type Object = St::Object;
         type Rotation = Set<members::rotation>;
         type Position = St::Position;
+        type Object = St::Object;
     }
     ///State transition - sets the `position` field to Set
     pub struct SetPosition<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPosition<St> {}
     impl<St: State> State for SetPosition<St> {
-        type Object = St::Object;
         type Rotation = St::Rotation;
         type Position = Set<members::position>;
+        type Object = St::Object;
+    }
+    ///State transition - sets the `object` field to Set
+    pub struct SetObject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObject<St> {}
+    impl<St: State> State for SetObject<St> {
+        type Rotation = St::Rotation;
+        type Position = St::Position;
+        type Object = Set<members::object>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `object` field
-        pub struct object(());
         ///Marker type for the `rotation` field
         pub struct rotation(());
         ///Marker type for the `position` field
         pub struct position(());
+        ///Marker type for the `object` field
+        pub struct object(());
     }
 }
 
@@ -1091,9 +1091,9 @@ where
 impl<S: BosStr, St> FurnishingBuilder<S, St>
 where
     St: furnishing_state::State,
-    St::Object: furnishing_state::IsSet,
     St::Rotation: furnishing_state::IsSet,
     St::Position: furnishing_state::IsSet,
+    St::Object: furnishing_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Furnishing<S> {
@@ -1128,85 +1128,85 @@ pub mod layout_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Floor;
-        type Wall;
-        type Size;
-        type Furnishings;
         type CreatedAt;
+        type Furnishings;
+        type Size;
+        type Wall;
+        type Floor;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Floor = Unset;
-        type Wall = Unset;
-        type Size = Unset;
-        type Furnishings = Unset;
         type CreatedAt = Unset;
+        type Furnishings = Unset;
+        type Size = Unset;
+        type Wall = Unset;
+        type Floor = Unset;
     }
-    ///State transition - sets the `floor` field to Set
-    pub struct SetFloor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFloor<St> {}
-    impl<St: State> State for SetFloor<St> {
-        type Floor = Set<members::floor>;
-        type Wall = St::Wall;
-        type Size = St::Size;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Furnishings = St::Furnishings;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `wall` field to Set
-    pub struct SetWall<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWall<St> {}
-    impl<St: State> State for SetWall<St> {
-        type Floor = St::Floor;
-        type Wall = Set<members::wall>;
         type Size = St::Size;
-        type Furnishings = St::Furnishings;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `size` field to Set
-    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSize<St> {}
-    impl<St: State> State for SetSize<St> {
-        type Floor = St::Floor;
         type Wall = St::Wall;
-        type Size = Set<members::size>;
-        type Furnishings = St::Furnishings;
-        type CreatedAt = St::CreatedAt;
+        type Floor = St::Floor;
     }
     ///State transition - sets the `furnishings` field to Set
     pub struct SetFurnishings<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFurnishings<St> {}
     impl<St: State> State for SetFurnishings<St> {
-        type Floor = St::Floor;
-        type Wall = St::Wall;
-        type Size = St::Size;
-        type Furnishings = Set<members::furnishings>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Furnishings = Set<members::furnishings>;
+        type Size = St::Size;
+        type Wall = St::Wall;
         type Floor = St::Floor;
+    }
+    ///State transition - sets the `size` field to Set
+    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSize<St> {}
+    impl<St: State> State for SetSize<St> {
+        type CreatedAt = St::CreatedAt;
+        type Furnishings = St::Furnishings;
+        type Size = Set<members::size>;
         type Wall = St::Wall;
+        type Floor = St::Floor;
+    }
+    ///State transition - sets the `wall` field to Set
+    pub struct SetWall<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWall<St> {}
+    impl<St: State> State for SetWall<St> {
+        type CreatedAt = St::CreatedAt;
+        type Furnishings = St::Furnishings;
         type Size = St::Size;
+        type Wall = Set<members::wall>;
+        type Floor = St::Floor;
+    }
+    ///State transition - sets the `floor` field to Set
+    pub struct SetFloor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFloor<St> {}
+    impl<St: State> State for SetFloor<St> {
+        type CreatedAt = St::CreatedAt;
         type Furnishings = St::Furnishings;
-        type CreatedAt = Set<members::created_at>;
+        type Size = St::Size;
+        type Wall = St::Wall;
+        type Floor = Set<members::floor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `floor` field
-        pub struct floor(());
-        ///Marker type for the `wall` field
-        pub struct wall(());
-        ///Marker type for the `size` field
-        pub struct size(());
-        ///Marker type for the `furnishings` field
-        pub struct furnishings(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `furnishings` field
+        pub struct furnishings(());
+        ///Marker type for the `size` field
+        pub struct size(());
+        ///Marker type for the `wall` field
+        pub struct wall(());
+        ///Marker type for the `floor` field
+        pub struct floor(());
     }
 }
 
@@ -1339,11 +1339,11 @@ where
 impl<S: BosStr, St> LayoutBuilder<S, St>
 where
     St: layout_state::State,
-    St::Floor: layout_state::IsSet,
-    St::Wall: layout_state::IsSet,
-    St::Size: layout_state::IsSet,
-    St::Furnishings: layout_state::IsSet,
     St::CreatedAt: layout_state::IsSet,
+    St::Furnishings: layout_state::IsSet,
+    St::Size: layout_state::IsSet,
+    St::Wall: layout_state::IsSet,
+    St::Floor: layout_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Layout<S> {
diff --git a/crates/jacquard-api/src/blue_atroom/room/object.rs b/crates/jacquard-api/src/blue_atroom/room/object.rs
index 821ba5c7..163fe525 100644
--- a/crates/jacquard-api/src/blue_atroom/room/object.rs
+++ b/crates/jacquard-api/src/blue_atroom/room/object.rs
@@ -341,67 +341,67 @@ pub mod object_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Model;
+        type Scale;
         type Name;
         type CreatedAt;
-        type Scale;
+        type Model;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Model = Unset;
+        type Scale = Unset;
         type Name = Unset;
         type CreatedAt = Unset;
-        type Scale = Unset;
+        type Model = Unset;
     }
-    ///State transition - sets the `model` field to Set
-    pub struct SetModel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetModel<St> {}
-    impl<St: State> State for SetModel<St> {
-        type Model = Set<members::model>;
+    ///State transition - sets the `scale` field to Set
+    pub struct SetScale<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScale<St> {}
+    impl<St: State> State for SetScale<St> {
+        type Scale = Set<members::scale>;
         type Name = St::Name;
         type CreatedAt = St::CreatedAt;
-        type Scale = St::Scale;
+        type Model = St::Model;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Model = St::Model;
+        type Scale = St::Scale;
         type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
-        type Scale = St::Scale;
+        type Model = St::Model;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Model = St::Model;
+        type Scale = St::Scale;
         type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
-        type Scale = St::Scale;
-    }
-    ///State transition - sets the `scale` field to Set
-    pub struct SetScale<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScale<St> {}
-    impl<St: State> State for SetScale<St> {
         type Model = St::Model;
+    }
+    ///State transition - sets the `model` field to Set
+    pub struct SetModel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetModel<St> {}
+    impl<St: State> State for SetModel<St> {
+        type Scale = St::Scale;
         type Name = St::Name;
         type CreatedAt = St::CreatedAt;
-        type Scale = Set<members::scale>;
+        type Model = Set<members::model>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `model` field
-        pub struct model(());
+        ///Marker type for the `scale` field
+        pub struct scale(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `scale` field
-        pub struct scale(());
+        ///Marker type for the `model` field
+        pub struct model(());
     }
 }
 
@@ -534,10 +534,10 @@ where
 impl<S: BosStr, St> ObjectBuilder<S, St>
 where
     St: object_state::State,
-    St::Model: object_state::IsSet,
+    St::Scale: object_state::IsSet,
     St::Name: object_state::IsSet,
     St::CreatedAt: object_state::IsSet,
-    St::Scale: object_state::IsSet,
+    St::Model: object_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Object<S> {
diff --git a/crates/jacquard-api/src/blue_backyard/feed/comment.rs b/crates/jacquard-api/src/blue_backyard/feed/comment.rs
index 8aad481e..5181781e 100644
--- a/crates/jacquard-api/src/blue_backyard/feed/comment.rs
+++ b/crates/jacquard-api/src/blue_backyard/feed/comment.rs
@@ -149,67 +149,67 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
         type Root;
         type Subject;
         type CreatedAt;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
         type Root = Unset;
         type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
-        type Root = St::Root;
-        type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
+        type Text = Unset;
     }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
-        type Text = St::Text;
         type Root = Set<members::root>;
         type Subject = St::Subject;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Text = St::Text;
         type Root = St::Root;
         type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Text = St::Text;
         type Root = St::Root;
         type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type Root = St::Root;
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `root` field
         pub struct root(());
         ///Marker type for the `subject` field
         pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -350,10 +350,10 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::Text: comment_state::IsSet,
     St::Root: comment_state::IsSet,
     St::Subject: comment_state::IsSet,
     St::CreatedAt: comment_state::IsSet,
+    St::Text: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/blue_backyard/feed/reblog.rs b/crates/jacquard-api/src/blue_backyard/feed/reblog.rs
index bdbb5dd8..c084874a 100644
--- a/crates/jacquard-api/src/blue_backyard/feed/reblog.rs
+++ b/crates/jacquard-api/src/blue_backyard/feed/reblog.rs
@@ -156,37 +156,37 @@ pub mod reblog_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -290,8 +290,8 @@ impl<S: BosStr, St: reblog_state::State> ReblogBuilder<S, St> {
 impl<S: BosStr, St> ReblogBuilder<S, St>
 where
     St: reblog_state::State,
-    St::CreatedAt: reblog_state::IsSet,
     St::Subject: reblog_state::IsSet,
+    St::CreatedAt: reblog_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reblog<S> {
diff --git a/crates/jacquard-api/src/blue_backyard/graph/block.rs b/crates/jacquard-api/src/blue_backyard/graph/block.rs
index 80aac425..898de39a 100644
--- a/crates/jacquard-api/src/blue_backyard/graph/block.rs
+++ b/crates/jacquard-api/src/blue_backyard/graph/block.rs
@@ -113,37 +113,37 @@ pub mod block_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> BlockBuilder<S, St>
 where
     St: block_state::State,
-    St::Subject: block_state::IsSet,
     St::CreatedAt: block_state::IsSet,
+    St::Subject: block_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Block<S> {
diff --git a/crates/jacquard-api/src/blue_backyard/richtext/facet.rs b/crates/jacquard-api/src/blue_backyard/richtext/facet.rs
index e4dbad06..4fc94d4c 100644
--- a/crates/jacquard-api/src/blue_backyard/richtext/facet.rs
+++ b/crates/jacquard-api/src/blue_backyard/richtext/facet.rs
@@ -558,37 +558,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteEnd;
         type ByteStart;
+        type ByteEnd;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteEnd = Unset;
         type ByteStart = Unset;
-    }
-    ///State transition - sets the `byte_end` field to Set
-    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
-    impl<St: State> State for SetByteEnd<St> {
-        type ByteEnd = Set<members::byte_end>;
-        type ByteStart = St::ByteStart;
+        type ByteEnd = Unset;
     }
     ///State transition - sets the `byte_start` field to Set
     pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteStart<St> {}
     impl<St: State> State for SetByteStart<St> {
-        type ByteEnd = St::ByteEnd;
         type ByteStart = Set<members::byte_start>;
+        type ByteEnd = St::ByteEnd;
+    }
+    ///State transition - sets the `byte_end` field to Set
+    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
+    impl<St: State> State for SetByteEnd<St> {
+        type ByteStart = St::ByteStart;
+        type ByteEnd = Set<members::byte_end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_end` field
-        pub struct byte_end(());
         ///Marker type for the `byte_start` field
         pub struct byte_start(());
+        ///Marker type for the `byte_end` field
+        pub struct byte_end(());
     }
 }
 
@@ -658,8 +658,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteEnd: byte_slice_state::IsSet,
     St::ByteStart: byte_slice_state::IsSet,
+    St::ByteEnd: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
@@ -789,37 +789,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Features;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Features = St::Features;
+        type Index = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Index = St::Index;
         type Features = Set<members::features>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Features = St::Features;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -889,8 +889,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Index: facet_state::IsSet,
     St::Features: facet_state::IsSet,
+    St::Index: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/blue_recipes/feed.rs b/crates/jacquard-api/src/blue_recipes/feed.rs
index 81506e01..3f44526b 100644
--- a/crates/jacquard-api/src/blue_recipes/feed.rs
+++ b/crates/jacquard-api/src/blue_recipes/feed.rs
@@ -332,83 +332,83 @@ pub mod recipe_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Author;
         type Uri;
-        type IndexedAt;
         type Record;
+        type IndexedAt;
+        type Author;
         type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Author = Unset;
         type Uri = Unset;
-        type IndexedAt = Unset;
         type Record = Unset;
+        type IndexedAt = Unset;
+        type Author = Unset;
         type Cid = Unset;
     }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Author = Set<members::author>;
-        type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
-        type Record = St::Record;
-        type Cid = St::Cid;
-    }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Author = St::Author;
         type Uri = Set<members::uri>;
-        type IndexedAt = St::IndexedAt;
         type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Uri = St::Uri;
+        type Record = Set<members::record>;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
         type Cid = St::Cid;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Author = St::Author;
         type Uri = St::Uri;
-        type IndexedAt = Set<members::indexed_at>;
         type Record = St::Record;
+        type IndexedAt = Set<members::indexed_at>;
+        type Author = St::Author;
         type Cid = St::Cid;
     }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Author = St::Author;
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
         type Uri = St::Uri;
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
-        type Record = Set<members::record>;
+        type Author = Set<members::author>;
         type Cid = St::Cid;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Author = St::Author;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
         type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
         type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
+        ///Marker type for the `author` field
+        pub struct author(());
         ///Marker type for the `cid` field
         pub struct cid(());
     }
@@ -543,10 +543,10 @@ where
 impl<S: BosStr, St> RecipeViewBuilder<S, St>
 where
     St: recipe_view_state::State,
-    St::Author: recipe_view_state::IsSet,
     St::Uri: recipe_view_state::IsSet,
-    St::IndexedAt: recipe_view_state::IsSet,
     St::Record: recipe_view_state::IsSet,
+    St::IndexedAt: recipe_view_state::IsSet,
+    St::Author: recipe_view_state::IsSet,
     St::Cid: recipe_view_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/blue_recipes/feed/recipe.rs b/crates/jacquard-api/src/blue_recipes/feed/recipe.rs
index 40133534..236c4dfb 100644
--- a/crates/jacquard-api/src/blue_recipes/feed/recipe.rs
+++ b/crates/jacquard-api/src/blue_recipes/feed/recipe.rs
@@ -472,51 +472,51 @@ pub mod recipe_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Ingredients;
         type Steps;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Ingredients = Unset;
         type Steps = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Ingredients = St::Ingredients;
-        type Steps = St::Steps;
+        type Title = Unset;
     }
     ///State transition - sets the `ingredients` field to Set
     pub struct SetIngredients<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIngredients<St> {}
     impl<St: State> State for SetIngredients<St> {
-        type Title = St::Title;
         type Ingredients = Set<members::ingredients>;
         type Steps = St::Steps;
+        type Title = St::Title;
     }
     ///State transition - sets the `steps` field to Set
     pub struct SetSteps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSteps<St> {}
     impl<St: State> State for SetSteps<St> {
-        type Title = St::Title;
         type Ingredients = St::Ingredients;
         type Steps = Set<members::steps>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Ingredients = St::Ingredients;
+        type Steps = St::Steps;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `ingredients` field
         pub struct ingredients(());
         ///Marker type for the `steps` field
         pub struct steps(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -679,9 +679,9 @@ where
 impl<S: BosStr, St> RecipeBuilder<S, St>
 where
     St: recipe_state::State,
-    St::Title: recipe_state::IsSet,
     St::Ingredients: recipe_state::IsSet,
     St::Steps: recipe_state::IsSet,
+    St::Title: recipe_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Recipe<S> {
diff --git a/crates/jacquard-api/src/blue_rito/feed/bookmark.rs b/crates/jacquard-api/src/blue_rito/feed/bookmark.rs
index 522532e1..7f602493 100644
--- a/crates/jacquard-api/src/blue_rito/feed/bookmark.rs
+++ b/crates/jacquard-api/src/blue_rito/feed/bookmark.rs
@@ -389,49 +389,49 @@ pub mod bookmark_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type Comments;
+        type Subject;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type Comments = Unset;
+        type Subject = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type Comments = St::Comments;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `comments` field to Set
     pub struct SetComments<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetComments<St> {}
     impl<St: State> State for SetComments<St> {
-        type Subject = St::Subject;
         type Comments = Set<members::comments>;
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Comments = St::Comments;
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type Comments = St::Comments;
+        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `comments` field
         pub struct comments(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -582,8 +582,8 @@ impl<S: BosStr, St: bookmark_state::State> BookmarkBuilder<S, St> {
 impl<S: BosStr, St> BookmarkBuilder<S, St>
 where
     St: bookmark_state::State,
-    St::Subject: bookmark_state::IsSet,
     St::Comments: bookmark_state::IsSet,
+    St::Subject: bookmark_state::IsSet,
     St::CreatedAt: bookmark_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/blue_rito/label/auto/post.rs b/crates/jacquard-api/src/blue_rito/label/auto/post.rs
index 72a2e0b2..3a23ad4b 100644
--- a/crates/jacquard-api/src/blue_rito/label/auto/post.rs
+++ b/crates/jacquard-api/src/blue_rito/label/auto/post.rs
@@ -122,85 +122,85 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type DurationInHours;
+        type CreatedAt;
         type AppliedTo;
         type Condition;
-        type DurationInHours;
         type Label;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type DurationInHours = Unset;
+        type CreatedAt = Unset;
         type AppliedTo = Unset;
         type Condition = Unset;
-        type DurationInHours = Unset;
         type Label = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `duration_in_hours` field to Set
+    pub struct SetDurationInHours<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDurationInHours<St> {}
+    impl<St: State> State for SetDurationInHours<St> {
+        type DurationInHours = Set<members::duration_in_hours>;
+        type CreatedAt = St::CreatedAt;
+        type AppliedTo = St::AppliedTo;
+        type Condition = St::Condition;
+        type Label = St::Label;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type DurationInHours = St::DurationInHours;
+        type CreatedAt = Set<members::created_at>;
+        type AppliedTo = St::AppliedTo;
+        type Condition = St::Condition;
+        type Label = St::Label;
     }
     ///State transition - sets the `applied_to` field to Set
     pub struct SetAppliedTo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAppliedTo<St> {}
     impl<St: State> State for SetAppliedTo<St> {
+        type DurationInHours = St::DurationInHours;
+        type CreatedAt = St::CreatedAt;
         type AppliedTo = Set<members::applied_to>;
         type Condition = St::Condition;
-        type DurationInHours = St::DurationInHours;
         type Label = St::Label;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `condition` field to Set
     pub struct SetCondition<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCondition<St> {}
     impl<St: State> State for SetCondition<St> {
-        type AppliedTo = St::AppliedTo;
-        type Condition = Set<members::condition>;
         type DurationInHours = St::DurationInHours;
-        type Label = St::Label;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `duration_in_hours` field to Set
-    pub struct SetDurationInHours<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDurationInHours<St> {}
-    impl<St: State> State for SetDurationInHours<St> {
         type AppliedTo = St::AppliedTo;
-        type Condition = St::Condition;
-        type DurationInHours = Set<members::duration_in_hours>;
+        type Condition = Set<members::condition>;
         type Label = St::Label;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `label` field to Set
     pub struct SetLabel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLabel<St> {}
     impl<St: State> State for SetLabel<St> {
-        type AppliedTo = St::AppliedTo;
-        type Condition = St::Condition;
         type DurationInHours = St::DurationInHours;
-        type Label = Set<members::label>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type AppliedTo = St::AppliedTo;
         type Condition = St::Condition;
-        type DurationInHours = St::DurationInHours;
-        type Label = St::Label;
-        type CreatedAt = Set<members::created_at>;
+        type Label = Set<members::label>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `duration_in_hours` field
+        pub struct duration_in_hours(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `applied_to` field
         pub struct applied_to(());
         ///Marker type for the `condition` field
         pub struct condition(());
-        ///Marker type for the `duration_in_hours` field
-        pub struct duration_in_hours(());
         ///Marker type for the `label` field
         pub struct label(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -340,11 +340,11 @@ where
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
+    St::DurationInHours: post_state::IsSet,
+    St::CreatedAt: post_state::IsSet,
     St::AppliedTo: post_state::IsSet,
     St::Condition: post_state::IsSet,
-    St::DurationInHours: post_state::IsSet,
     St::Label: post_state::IsSet,
-    St::CreatedAt: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/blue_rito/service/get_schema.rs b/crates/jacquard-api/src/blue_rito/service/get_schema.rs
index b57d6e2c..c467e3f1 100644
--- a/crates/jacquard-api/src/blue_rito/service/get_schema.rs
+++ b/crates/jacquard-api/src/blue_rito/service/get_schema.rs
@@ -131,49 +131,49 @@ pub mod langs_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Lang;
+        type Title;
         type Moderation;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Lang = Unset;
+        type Title = Unset;
         type Moderation = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Lang = St::Lang;
-        type Moderation = St::Moderation;
-    }
     ///State transition - sets the `lang` field to Set
     pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLang<St> {}
     impl<St: State> State for SetLang<St> {
-        type Title = St::Title;
         type Lang = Set<members::lang>;
+        type Title = St::Title;
+        type Moderation = St::Moderation;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Lang = St::Lang;
+        type Title = Set<members::title>;
         type Moderation = St::Moderation;
     }
     ///State transition - sets the `moderation` field to Set
     pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetModeration<St> {}
     impl<St: State> State for SetModeration<St> {
-        type Title = St::Title;
         type Lang = St::Lang;
+        type Title = St::Title;
         type Moderation = Set<members::moderation>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `lang` field
         pub struct lang(());
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `moderation` field
         pub struct moderation(());
     }
@@ -277,8 +277,8 @@ where
 impl<S: BosStr, St> LangsBuilder<S, St>
 where
     St: langs_state::State,
-    St::Title: langs_state::IsSet,
     St::Lang: langs_state::IsSet,
+    St::Title: langs_state::IsSet,
     St::Moderation: langs_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/blue_skytalk/talk/comment.rs b/crates/jacquard-api/src/blue_skytalk/talk/comment.rs
index bb6c08f7..98e3b4e7 100644
--- a/crates/jacquard-api/src/blue_skytalk/talk/comment.rs
+++ b/crates/jacquard-api/src/blue_skytalk/talk/comment.rs
@@ -155,50 +155,50 @@ pub mod comment_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type ThreadUri;
-        type Text;
         type CreatedAt;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type ThreadUri = Unset;
-        type Text = Unset;
         type CreatedAt = Unset;
+        type Text = Unset;
     }
     ///State transition - sets the `thread_uri` field to Set
     pub struct SetThreadUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetThreadUri<St> {}
     impl<St: State> State for SetThreadUri<St> {
         type ThreadUri = Set<members::thread_uri>;
-        type Text = St::Text;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type ThreadUri = St::ThreadUri;
-        type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type ThreadUri = St::ThreadUri;
-        type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type ThreadUri = St::ThreadUri;
+        type CreatedAt = St::CreatedAt;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `thread_uri` field
         pub struct thread_uri(());
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -301,8 +301,8 @@ impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
     St::ThreadUri: comment_state::IsSet,
-    St::Text: comment_state::IsSet,
     St::CreatedAt: comment_state::IsSet,
+    St::Text: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/bond_biblio/book.rs b/crates/jacquard-api/src/bond_biblio/book.rs
index 22169f82..49ad967d 100644
--- a/crates/jacquard-api/src/bond_biblio/book.rs
+++ b/crates/jacquard-api/src/bond_biblio/book.rs
@@ -154,49 +154,49 @@ pub mod book_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type CreatedAt;
+        type Title;
         type Authors;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type CreatedAt = Unset;
+        type Title = Unset;
         type Authors = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type CreatedAt = St::CreatedAt;
-        type Authors = St::Authors;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Title = St::Title;
         type CreatedAt = Set<members::created_at>;
+        type Title = St::Title;
+        type Authors = St::Authors;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
+        type Title = Set<members::title>;
         type Authors = St::Authors;
     }
     ///State transition - sets the `authors` field to Set
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
-        type Title = St::Title;
         type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
         type Authors = Set<members::authors>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `authors` field
         pub struct authors(());
     }
@@ -300,8 +300,8 @@ where
 impl<S: BosStr, St> BookBuilder<S, St>
 where
     St: book_state::State,
-    St::Title: book_state::IsSet,
     St::CreatedAt: book_state::IsSet,
+    St::Title: book_state::IsSet,
     St::Authors: book_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/bond_biblio/list.rs b/crates/jacquard-api/src/bond_biblio/list.rs
index 72edf0a8..d2912284 100644
--- a/crates/jacquard-api/src/bond_biblio/list.rs
+++ b/crates/jacquard-api/src/bond_biblio/list.rs
@@ -171,84 +171,84 @@ pub mod list_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
+        type Librarians;
         type Books;
-        type Title;
         type Duedate;
-        type Librarians;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
+        type Librarians = Unset;
         type Books = Unset;
-        type Title = Unset;
         type Duedate = Unset;
-        type Librarians = Unset;
+        type Title = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
+        type Librarians = St::Librarians;
         type Books = St::Books;
+        type Duedate = St::Duedate;
         type Title = St::Title;
+    }
+    ///State transition - sets the `librarians` field to Set
+    pub struct SetLibrarians<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLibrarians<St> {}
+    impl<St: State> State for SetLibrarians<St> {
+        type CreatedAt = St::CreatedAt;
+        type Librarians = Set<members::librarians>;
+        type Books = St::Books;
         type Duedate = St::Duedate;
-        type Librarians = St::Librarians;
+        type Title = St::Title;
     }
     ///State transition - sets the `books` field to Set
     pub struct SetBooks<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBooks<St> {}
     impl<St: State> State for SetBooks<St> {
         type CreatedAt = St::CreatedAt;
-        type Books = Set<members::books>;
-        type Title = St::Title;
-        type Duedate = St::Duedate;
         type Librarians = St::Librarians;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
-        type Books = St::Books;
-        type Title = Set<members::title>;
+        type Books = Set<members::books>;
         type Duedate = St::Duedate;
-        type Librarians = St::Librarians;
+        type Title = St::Title;
     }
     ///State transition - sets the `duedate` field to Set
     pub struct SetDuedate<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDuedate<St> {}
     impl<St: State> State for SetDuedate<St> {
         type CreatedAt = St::CreatedAt;
+        type Librarians = St::Librarians;
         type Books = St::Books;
-        type Title = St::Title;
         type Duedate = Set<members::duedate>;
-        type Librarians = St::Librarians;
+        type Title = St::Title;
     }
-    ///State transition - sets the `librarians` field to Set
-    pub struct SetLibrarians<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLibrarians<St> {}
-    impl<St: State> State for SetLibrarians<St> {
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
         type CreatedAt = St::CreatedAt;
+        type Librarians = St::Librarians;
         type Books = St::Books;
-        type Title = St::Title;
         type Duedate = St::Duedate;
-        type Librarians = Set<members::librarians>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `librarians` field
+        pub struct librarians(());
         ///Marker type for the `books` field
         pub struct books(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `duedate` field
         pub struct duedate(());
-        ///Marker type for the `librarians` field
-        pub struct librarians(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -396,10 +396,10 @@ impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
     St::CreatedAt: list_state::IsSet,
+    St::Librarians: list_state::IsSet,
     St::Books: list_state::IsSet,
-    St::Title: list_state::IsSet,
     St::Duedate: list_state::IsSet,
-    St::Librarians: list_state::IsSet,
+    St::Title: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/bond_biblio/stamp.rs b/crates/jacquard-api/src/bond_biblio/stamp.rs
index 6c31e2d3..045745db 100644
--- a/crates/jacquard-api/src/bond_biblio/stamp.rs
+++ b/crates/jacquard-api/src/bond_biblio/stamp.rs
@@ -116,49 +116,49 @@ pub mod stamp_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type List;
         type CreatedAt;
+        type List;
         type Book;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type List = Unset;
         type CreatedAt = Unset;
+        type List = Unset;
         type Book = Unset;
     }
-    ///State transition - sets the `list` field to Set
-    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetList<St> {}
-    impl<St: State> State for SetList<St> {
-        type List = Set<members::list>;
-        type CreatedAt = St::CreatedAt;
-        type Book = St::Book;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type List = St::List;
         type CreatedAt = Set<members::created_at>;
+        type List = St::List;
+        type Book = St::Book;
+    }
+    ///State transition - sets the `list` field to Set
+    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetList<St> {}
+    impl<St: State> State for SetList<St> {
+        type CreatedAt = St::CreatedAt;
+        type List = Set<members::list>;
         type Book = St::Book;
     }
     ///State transition - sets the `book` field to Set
     pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBook<St> {}
     impl<St: State> State for SetBook<St> {
-        type List = St::List;
         type CreatedAt = St::CreatedAt;
+        type List = St::List;
         type Book = Set<members::book>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `list` field
-        pub struct list(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `list` field
+        pub struct list(());
         ///Marker type for the `book` field
         pub struct book(());
     }
@@ -249,8 +249,8 @@ where
 impl<S: BosStr, St> StampBuilder<S, St>
 where
     St: stamp_state::State,
-    St::List: stamp_state::IsSet,
     St::CreatedAt: stamp_state::IsSet,
+    St::List: stamp_state::IsSet,
     St::Book: stamp_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/buzz_bookhive.rs b/crates/jacquard-api/src/buzz_bookhive.rs
index 801c0a87..c760db70 100644
--- a/crates/jacquard-api/src/buzz_bookhive.rs
+++ b/crates/jacquard-api/src/buzz_bookhive.rs
@@ -746,93 +746,97 @@ pub mod activity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type UserHandle;
+        type UserDid;
         type Type;
         type CreatedAt;
         type HiveId;
         type Title;
-        type UserDid;
-        type UserHandle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type UserHandle = Unset;
+        type UserDid = Unset;
         type Type = Unset;
         type CreatedAt = Unset;
         type HiveId = Unset;
         type Title = Unset;
-        type UserDid = Unset;
-        type UserHandle = Unset;
+    }
+    ///State transition - sets the `user_handle` field to Set
+    pub struct SetUserHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserHandle<St> {}
+    impl<St: State> State for SetUserHandle<St> {
+        type UserHandle = Set<members::user_handle>;
+        type UserDid = St::UserDid;
+        type Type = St::Type;
+        type CreatedAt = St::CreatedAt;
+        type HiveId = St::HiveId;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `user_did` field to Set
+    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserDid<St> {}
+    impl<St: State> State for SetUserDid<St> {
+        type UserHandle = St::UserHandle;
+        type UserDid = Set<members::user_did>;
+        type Type = St::Type;
+        type CreatedAt = St::CreatedAt;
+        type HiveId = St::HiveId;
+        type Title = St::Title;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
+        type UserHandle = St::UserHandle;
+        type UserDid = St::UserDid;
         type Type = Set<members::r#type>;
         type CreatedAt = St::CreatedAt;
         type HiveId = St::HiveId;
         type Title = St::Title;
-        type UserDid = St::UserDid;
-        type UserHandle = St::UserHandle;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type UserHandle = St::UserHandle;
+        type UserDid = St::UserDid;
         type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
         type HiveId = St::HiveId;
         type Title = St::Title;
-        type UserDid = St::UserDid;
-        type UserHandle = St::UserHandle;
     }
     ///State transition - sets the `hive_id` field to Set
     pub struct SetHiveId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHiveId<St> {}
     impl<St: State> State for SetHiveId<St> {
+        type UserHandle = St::UserHandle;
+        type UserDid = St::UserDid;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type HiveId = Set<members::hive_id>;
         type Title = St::Title;
-        type UserDid = St::UserDid;
-        type UserHandle = St::UserHandle;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
-        type HiveId = St::HiveId;
-        type Title = Set<members::title>;
-        type UserDid = St::UserDid;
         type UserHandle = St::UserHandle;
-    }
-    ///State transition - sets the `user_did` field to Set
-    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserDid<St> {}
-    impl<St: State> State for SetUserDid<St> {
-        type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
-        type HiveId = St::HiveId;
-        type Title = St::Title;
-        type UserDid = Set<members::user_did>;
-        type UserHandle = St::UserHandle;
-    }
-    ///State transition - sets the `user_handle` field to Set
-    pub struct SetUserHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserHandle<St> {}
-    impl<St: State> State for SetUserHandle<St> {
+        type UserDid = St::UserDid;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type HiveId = St::HiveId;
-        type Title = St::Title;
-        type UserDid = St::UserDid;
-        type UserHandle = Set<members::user_handle>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `user_handle` field
+        pub struct user_handle(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
         ///Marker type for the `type` field
         pub struct r#type(());
         ///Marker type for the `created_at` field
@@ -841,10 +845,6 @@ pub mod activity_state {
         pub struct hive_id(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
-        ///Marker type for the `user_handle` field
-        pub struct user_handle(());
     }
 }
 
@@ -997,12 +997,12 @@ where
 impl<S: BosStr, St> ActivityBuilder<S, St>
 where
     St: activity_state::State,
+    St::UserHandle: activity_state::IsSet,
+    St::UserDid: activity_state::IsSet,
     St::Type: activity_state::IsSet,
     St::CreatedAt: activity_state::IsSet,
     St::HiveId: activity_state::IsSet,
     St::Title: activity_state::IsSet,
-    St::UserDid: activity_state::IsSet,
-    St::UserHandle: activity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Activity<S> {
@@ -1799,105 +1799,105 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
-        type Comment;
         type CreatedAt;
-        type Book;
         type Parent;
         type Did;
+        type Handle;
+        type Book;
+        type Comment;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
-        type Comment = Unset;
         type CreatedAt = Unset;
-        type Book = Unset;
         type Parent = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Comment = St::Comment;
-        type CreatedAt = St::CreatedAt;
-        type Book = St::Book;
-        type Parent = St::Parent;
-        type Did = St::Did;
-    }
-    ///State transition - sets the `comment` field to Set
-    pub struct SetComment<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetComment<St> {}
-    impl<St: State> State for SetComment<St> {
-        type Handle = St::Handle;
-        type Comment = Set<members::comment>;
-        type CreatedAt = St::CreatedAt;
-        type Book = St::Book;
-        type Parent = St::Parent;
-        type Did = St::Did;
+        type Handle = Unset;
+        type Book = Unset;
+        type Comment = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Handle = St::Handle;
-        type Comment = St::Comment;
         type CreatedAt = Set<members::created_at>;
-        type Book = St::Book;
         type Parent = St::Parent;
         type Did = St::Did;
-    }
-    ///State transition - sets the `book` field to Set
-    pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBook<St> {}
-    impl<St: State> State for SetBook<St> {
         type Handle = St::Handle;
+        type Book = St::Book;
         type Comment = St::Comment;
-        type CreatedAt = St::CreatedAt;
-        type Book = Set<members::book>;
-        type Parent = St::Parent;
-        type Did = St::Did;
     }
     ///State transition - sets the `parent` field to Set
     pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParent<St> {}
     impl<St: State> State for SetParent<St> {
-        type Handle = St::Handle;
-        type Comment = St::Comment;
         type CreatedAt = St::CreatedAt;
-        type Book = St::Book;
         type Parent = Set<members::parent>;
         type Did = St::Did;
+        type Handle = St::Handle;
+        type Book = St::Book;
+        type Comment = St::Comment;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
+        type CreatedAt = St::CreatedAt;
+        type Parent = St::Parent;
+        type Did = Set<members::did>;
         type Handle = St::Handle;
+        type Book = St::Book;
         type Comment = St::Comment;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
         type CreatedAt = St::CreatedAt;
+        type Parent = St::Parent;
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
         type Book = St::Book;
+        type Comment = St::Comment;
+    }
+    ///State transition - sets the `book` field to Set
+    pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBook<St> {}
+    impl<St: State> State for SetBook<St> {
+        type CreatedAt = St::CreatedAt;
         type Parent = St::Parent;
-        type Did = Set<members::did>;
+        type Did = St::Did;
+        type Handle = St::Handle;
+        type Book = Set<members::book>;
+        type Comment = St::Comment;
+    }
+    ///State transition - sets the `comment` field to Set
+    pub struct SetComment<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetComment<St> {}
+    impl<St: State> State for SetComment<St> {
+        type CreatedAt = St::CreatedAt;
+        type Parent = St::Parent;
+        type Did = St::Did;
+        type Handle = St::Handle;
+        type Book = St::Book;
+        type Comment = Set<members::comment>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
-        ///Marker type for the `comment` field
-        pub struct comment(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `book` field
-        pub struct book(());
         ///Marker type for the `parent` field
         pub struct parent(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
+        ///Marker type for the `book` field
+        pub struct book(());
+        ///Marker type for the `comment` field
+        pub struct comment(());
     }
 }
 
@@ -2050,12 +2050,12 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::Handle: comment_state::IsSet,
-    St::Comment: comment_state::IsSet,
     St::CreatedAt: comment_state::IsSet,
-    St::Book: comment_state::IsSet,
     St::Parent: comment_state::IsSet,
     St::Did: comment_state::IsSet,
+    St::Handle: comment_state::IsSet,
+    St::Book: comment_state::IsSet,
+    St::Comment: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
@@ -2093,67 +2093,67 @@ pub mod profile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Reviews;
+        type BooksRead;
         type DisplayName;
         type Handle;
-        type BooksRead;
+        type Reviews;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Reviews = Unset;
+        type BooksRead = Unset;
         type DisplayName = Unset;
         type Handle = Unset;
-        type BooksRead = Unset;
+        type Reviews = Unset;
     }
-    ///State transition - sets the `reviews` field to Set
-    pub struct SetReviews<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReviews<St> {}
-    impl<St: State> State for SetReviews<St> {
-        type Reviews = Set<members::reviews>;
+    ///State transition - sets the `books_read` field to Set
+    pub struct SetBooksRead<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBooksRead<St> {}
+    impl<St: State> State for SetBooksRead<St> {
+        type BooksRead = Set<members::books_read>;
         type DisplayName = St::DisplayName;
         type Handle = St::Handle;
-        type BooksRead = St::BooksRead;
+        type Reviews = St::Reviews;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
-        type Reviews = St::Reviews;
+        type BooksRead = St::BooksRead;
         type DisplayName = Set<members::display_name>;
         type Handle = St::Handle;
-        type BooksRead = St::BooksRead;
+        type Reviews = St::Reviews;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Reviews = St::Reviews;
+        type BooksRead = St::BooksRead;
         type DisplayName = St::DisplayName;
         type Handle = Set<members::handle>;
-        type BooksRead = St::BooksRead;
-    }
-    ///State transition - sets the `books_read` field to Set
-    pub struct SetBooksRead<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBooksRead<St> {}
-    impl<St: State> State for SetBooksRead<St> {
         type Reviews = St::Reviews;
+    }
+    ///State transition - sets the `reviews` field to Set
+    pub struct SetReviews<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReviews<St> {}
+    impl<St: State> State for SetReviews<St> {
+        type BooksRead = St::BooksRead;
         type DisplayName = St::DisplayName;
         type Handle = St::Handle;
-        type BooksRead = Set<members::books_read>;
+        type Reviews = Set<members::reviews>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `reviews` field
-        pub struct reviews(());
+        ///Marker type for the `books_read` field
+        pub struct books_read(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
         ///Marker type for the `handle` field
         pub struct handle(());
-        ///Marker type for the `books_read` field
-        pub struct books_read(());
+        ///Marker type for the `reviews` field
+        pub struct reviews(());
     }
 }
 
@@ -2308,10 +2308,10 @@ where
 impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
-    St::Reviews: profile_state::IsSet,
+    St::BooksRead: profile_state::IsSet,
     St::DisplayName: profile_state::IsSet,
     St::Handle: profile_state::IsSet,
-    St::BooksRead: profile_state::IsSet,
+    St::Reviews: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
@@ -2351,65 +2351,65 @@ pub mod review_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Did;
         type Review;
+        type CreatedAt;
         type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Did = Unset;
         type Review = Unset;
+        type CreatedAt = Unset;
         type Handle = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Did = St::Did;
-        type Review = St::Review;
-        type Handle = St::Handle;
-    }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type CreatedAt = St::CreatedAt;
         type Did = Set<members::did>;
         type Review = St::Review;
+        type CreatedAt = St::CreatedAt;
         type Handle = St::Handle;
     }
     ///State transition - sets the `review` field to Set
     pub struct SetReview<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReview<St> {}
     impl<St: State> State for SetReview<St> {
-        type CreatedAt = St::CreatedAt;
         type Did = St::Did;
         type Review = Set<members::review>;
+        type CreatedAt = St::CreatedAt;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Did = St::Did;
+        type Review = St::Review;
+        type CreatedAt = Set<members::created_at>;
         type Handle = St::Handle;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type CreatedAt = St::CreatedAt;
         type Did = St::Did;
         type Review = St::Review;
+        type CreatedAt = St::CreatedAt;
         type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `review` field
         pub struct review(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `handle` field
         pub struct handle(());
     }
@@ -2532,9 +2532,9 @@ impl<S: BosStr, St: review_state::State> ReviewBuilder<S, St> {
 impl<S: BosStr, St> ReviewBuilder<S, St>
 where
     St: review_state::State,
-    St::CreatedAt: review_state::IsSet,
     St::Did: review_state::IsSet,
     St::Review: review_state::IsSet,
+    St::CreatedAt: review_state::IsSet,
     St::Handle: review_state::IsSet,
 {
     /// Build the final struct.
@@ -2571,105 +2571,105 @@ pub mod user_book_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Thumbnail;
-        type UserDid;
         type Title;
         type HiveId;
+        type CreatedAt;
+        type UserDid;
         type Authors;
+        type Thumbnail;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Thumbnail = Unset;
-        type UserDid = Unset;
         type Title = Unset;
         type HiveId = Unset;
+        type CreatedAt = Unset;
+        type UserDid = Unset;
         type Authors = Unset;
+        type Thumbnail = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Thumbnail = St::Thumbnail;
-        type UserDid = St::UserDid;
-        type Title = St::Title;
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
         type HiveId = St::HiveId;
+        type CreatedAt = St::CreatedAt;
+        type UserDid = St::UserDid;
         type Authors = St::Authors;
+        type Thumbnail = St::Thumbnail;
     }
-    ///State transition - sets the `thumbnail` field to Set
-    pub struct SetThumbnail<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetThumbnail<St> {}
-    impl<St: State> State for SetThumbnail<St> {
+    ///State transition - sets the `hive_id` field to Set
+    pub struct SetHiveId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHiveId<St> {}
+    impl<St: State> State for SetHiveId<St> {
+        type Title = St::Title;
+        type HiveId = Set<members::hive_id>;
         type CreatedAt = St::CreatedAt;
-        type Thumbnail = Set<members::thumbnail>;
         type UserDid = St::UserDid;
+        type Authors = St::Authors;
+        type Thumbnail = St::Thumbnail;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Title = St::Title;
         type HiveId = St::HiveId;
+        type CreatedAt = Set<members::created_at>;
+        type UserDid = St::UserDid;
         type Authors = St::Authors;
+        type Thumbnail = St::Thumbnail;
     }
     ///State transition - sets the `user_did` field to Set
     pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUserDid<St> {}
     impl<St: State> State for SetUserDid<St> {
-        type CreatedAt = St::CreatedAt;
-        type Thumbnail = St::Thumbnail;
-        type UserDid = Set<members::user_did>;
         type Title = St::Title;
         type HiveId = St::HiveId;
-        type Authors = St::Authors;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
         type CreatedAt = St::CreatedAt;
-        type Thumbnail = St::Thumbnail;
-        type UserDid = St::UserDid;
-        type Title = Set<members::title>;
-        type HiveId = St::HiveId;
+        type UserDid = Set<members::user_did>;
         type Authors = St::Authors;
-    }
-    ///State transition - sets the `hive_id` field to Set
-    pub struct SetHiveId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHiveId<St> {}
-    impl<St: State> State for SetHiveId<St> {
-        type CreatedAt = St::CreatedAt;
         type Thumbnail = St::Thumbnail;
-        type UserDid = St::UserDid;
-        type Title = St::Title;
-        type HiveId = Set<members::hive_id>;
-        type Authors = St::Authors;
     }
     ///State transition - sets the `authors` field to Set
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
+        type Title = St::Title;
+        type HiveId = St::HiveId;
         type CreatedAt = St::CreatedAt;
-        type Thumbnail = St::Thumbnail;
         type UserDid = St::UserDid;
+        type Authors = Set<members::authors>;
+        type Thumbnail = St::Thumbnail;
+    }
+    ///State transition - sets the `thumbnail` field to Set
+    pub struct SetThumbnail<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetThumbnail<St> {}
+    impl<St: State> State for SetThumbnail<St> {
         type Title = St::Title;
         type HiveId = St::HiveId;
-        type Authors = Set<members::authors>;
+        type CreatedAt = St::CreatedAt;
+        type UserDid = St::UserDid;
+        type Authors = St::Authors;
+        type Thumbnail = Set<members::thumbnail>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `thumbnail` field
-        pub struct thumbnail(());
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `hive_id` field
         pub struct hive_id(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
         ///Marker type for the `authors` field
         pub struct authors(());
+        ///Marker type for the `thumbnail` field
+        pub struct thumbnail(());
     }
 }
 
@@ -2985,12 +2985,12 @@ impl<S: BosStr, St: user_book_state::State> UserBookBuilder<S, St> {
 impl<S: BosStr, St> UserBookBuilder<S, St>
 where
     St: user_book_state::State,
-    St::CreatedAt: user_book_state::IsSet,
-    St::Thumbnail: user_book_state::IsSet,
-    St::UserDid: user_book_state::IsSet,
     St::Title: user_book_state::IsSet,
     St::HiveId: user_book_state::IsSet,
+    St::CreatedAt: user_book_state::IsSet,
+    St::UserDid: user_book_state::IsSet,
     St::Authors: user_book_state::IsSet,
+    St::Thumbnail: user_book_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UserBook<S> {
diff --git a/crates/jacquard-api/src/buzz_bookhive/book.rs b/crates/jacquard-api/src/buzz_bookhive/book.rs
index cb394a34..9424212b 100644
--- a/crates/jacquard-api/src/buzz_bookhive/book.rs
+++ b/crates/jacquard-api/src/buzz_bookhive/book.rs
@@ -343,67 +343,67 @@ pub mod book_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Authors;
         type CreatedAt;
-        type HiveId;
         type Title;
+        type HiveId;
+        type Authors;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Authors = Unset;
         type CreatedAt = Unset;
-        type HiveId = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `authors` field to Set
-    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthors<St> {}
-    impl<St: State> State for SetAuthors<St> {
-        type Authors = Set<members::authors>;
-        type CreatedAt = St::CreatedAt;
-        type HiveId = St::HiveId;
-        type Title = St::Title;
+        type HiveId = Unset;
+        type Authors = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Authors = St::Authors;
         type CreatedAt = Set<members::created_at>;
-        type HiveId = St::HiveId;
         type Title = St::Title;
+        type HiveId = St::HiveId;
+        type Authors = St::Authors;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
+        type Title = Set<members::title>;
+        type HiveId = St::HiveId;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `hive_id` field to Set
     pub struct SetHiveId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHiveId<St> {}
     impl<St: State> State for SetHiveId<St> {
-        type Authors = St::Authors;
         type CreatedAt = St::CreatedAt;
-        type HiveId = Set<members::hive_id>;
         type Title = St::Title;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
+        type HiveId = Set<members::hive_id>;
         type Authors = St::Authors;
+    }
+    ///State transition - sets the `authors` field to Set
+    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthors<St> {}
+    impl<St: State> State for SetAuthors<St> {
         type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
         type HiveId = St::HiveId;
-        type Title = Set<members::title>;
+        type Authors = Set<members::authors>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `authors` field
-        pub struct authors(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `hive_id` field
-        pub struct hive_id(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `hive_id` field
+        pub struct hive_id(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
     }
 }
 
@@ -614,10 +614,10 @@ where
 impl<S: BosStr, St> BookBuilder<S, St>
 where
     St: book_state::State,
-    St::Authors: book_state::IsSet,
     St::CreatedAt: book_state::IsSet,
-    St::HiveId: book_state::IsSet,
     St::Title: book_state::IsSet,
+    St::HiveId: book_state::IsSet,
+    St::Authors: book_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Book<S> {
diff --git a/crates/jacquard-api/src/buzz_bookhive/buzz.rs b/crates/jacquard-api/src/buzz_bookhive/buzz.rs
index a67008f0..a64eb6a7 100644
--- a/crates/jacquard-api/src/buzz_bookhive/buzz.rs
+++ b/crates/jacquard-api/src/buzz_bookhive/buzz.rs
@@ -141,65 +141,65 @@ pub mod buzz_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Book;
         type Comment;
+        type Book;
+        type CreatedAt;
         type Parent;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Book = Unset;
         type Comment = Unset;
+        type Book = Unset;
+        type CreatedAt = Unset;
         type Parent = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `comment` field to Set
+    pub struct SetComment<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetComment<St> {}
+    impl<St: State> State for SetComment<St> {
+        type Comment = Set<members::comment>;
         type Book = St::Book;
-        type Comment = St::Comment;
+        type CreatedAt = St::CreatedAt;
         type Parent = St::Parent;
     }
     ///State transition - sets the `book` field to Set
     pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBook<St> {}
     impl<St: State> State for SetBook<St> {
-        type CreatedAt = St::CreatedAt;
-        type Book = Set<members::book>;
         type Comment = St::Comment;
+        type Book = Set<members::book>;
+        type CreatedAt = St::CreatedAt;
         type Parent = St::Parent;
     }
-    ///State transition - sets the `comment` field to Set
-    pub struct SetComment<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetComment<St> {}
-    impl<St: State> State for SetComment<St> {
-        type CreatedAt = St::CreatedAt;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Comment = St::Comment;
         type Book = St::Book;
-        type Comment = Set<members::comment>;
+        type CreatedAt = Set<members::created_at>;
         type Parent = St::Parent;
     }
     ///State transition - sets the `parent` field to Set
     pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParent<St> {}
     impl<St: State> State for SetParent<St> {
-        type CreatedAt = St::CreatedAt;
-        type Book = St::Book;
         type Comment = St::Comment;
+        type Book = St::Book;
+        type CreatedAt = St::CreatedAt;
         type Parent = Set<members::parent>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `book` field
-        pub struct book(());
         ///Marker type for the `comment` field
         pub struct comment(());
+        ///Marker type for the `book` field
+        pub struct book(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `parent` field
         pub struct parent(());
     }
@@ -309,9 +309,9 @@ where
 impl<S: BosStr, St> BuzzBuilder<S, St>
 where
     St: buzz_state::State,
-    St::CreatedAt: buzz_state::IsSet,
-    St::Book: buzz_state::IsSet,
     St::Comment: buzz_state::IsSet,
+    St::Book: buzz_state::IsSet,
+    St::CreatedAt: buzz_state::IsSet,
     St::Parent: buzz_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/buzz_bookhive/hive_book.rs b/crates/jacquard-api/src/buzz_bookhive/hive_book.rs
index ec7fcf86..760a1a7b 100644
--- a/crates/jacquard-api/src/buzz_bookhive/hive_book.rs
+++ b/crates/jacquard-api/src/buzz_bookhive/hive_book.rs
@@ -217,105 +217,105 @@ pub mod hive_book_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type UpdatedAt;
         type Thumbnail;
         type Id;
-        type CreatedAt;
-        type Authors;
-        type UpdatedAt;
         type Title;
+        type Authors;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type UpdatedAt = Unset;
         type Thumbnail = Unset;
         type Id = Unset;
-        type CreatedAt = Unset;
-        type Authors = Unset;
-        type UpdatedAt = Unset;
         type Title = Unset;
+        type Authors = Unset;
+        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type UpdatedAt = Set<members::updated_at>;
+        type Thumbnail = St::Thumbnail;
+        type Id = St::Id;
+        type Title = St::Title;
+        type Authors = St::Authors;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `thumbnail` field to Set
     pub struct SetThumbnail<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetThumbnail<St> {}
     impl<St: State> State for SetThumbnail<St> {
+        type UpdatedAt = St::UpdatedAt;
         type Thumbnail = Set<members::thumbnail>;
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type Authors = St::Authors;
-        type UpdatedAt = St::UpdatedAt;
         type Title = St::Title;
+        type Authors = St::Authors;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
+        type UpdatedAt = St::UpdatedAt;
         type Thumbnail = St::Thumbnail;
         type Id = Set<members::id>;
-        type CreatedAt = St::CreatedAt;
-        type Authors = St::Authors;
-        type UpdatedAt = St::UpdatedAt;
         type Title = St::Title;
+        type Authors = St::Authors;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type UpdatedAt = St::UpdatedAt;
         type Thumbnail = St::Thumbnail;
         type Id = St::Id;
-        type CreatedAt = Set<members::created_at>;
+        type Title = Set<members::title>;
         type Authors = St::Authors;
-        type UpdatedAt = St::UpdatedAt;
-        type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `authors` field to Set
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
-        type Thumbnail = St::Thumbnail;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type Authors = Set<members::authors>;
         type UpdatedAt = St::UpdatedAt;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
         type Thumbnail = St::Thumbnail;
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type Authors = St::Authors;
-        type UpdatedAt = Set<members::updated_at>;
         type Title = St::Title;
+        type Authors = Set<members::authors>;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type UpdatedAt = St::UpdatedAt;
         type Thumbnail = St::Thumbnail;
         type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
         type Authors = St::Authors;
-        type UpdatedAt = St::UpdatedAt;
-        type Title = Set<members::title>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
         ///Marker type for the `thumbnail` field
         pub struct thumbnail(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `authors` field
-        pub struct authors(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -595,12 +595,12 @@ where
 impl<S: BosStr, St> HiveBookBuilder<S, St>
 where
     St: hive_book_state::State,
+    St::UpdatedAt: hive_book_state::IsSet,
     St::Thumbnail: hive_book_state::IsSet,
     St::Id: hive_book_state::IsSet,
-    St::CreatedAt: hive_book_state::IsSet,
-    St::Authors: hive_book_state::IsSet,
-    St::UpdatedAt: hive_book_state::IsSet,
     St::Title: hive_book_state::IsSet,
+    St::Authors: hive_book_state::IsSet,
+    St::CreatedAt: hive_book_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> HiveBook<S> {
diff --git a/crates/jacquard-api/src/cat_vt3e/gallery/group_item.rs b/crates/jacquard-api/src/cat_vt3e/gallery/group_item.rs
index 83a18b27..73b68a56 100644
--- a/crates/jacquard-api/src/cat_vt3e/gallery/group_item.rs
+++ b/crates/jacquard-api/src/cat_vt3e/gallery/group_item.rs
@@ -117,51 +117,51 @@ pub mod group_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type AddedAt;
         type Group;
         type Image;
-        type AddedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type AddedAt = Unset;
         type Group = Unset;
         type Image = Unset;
-        type AddedAt = Unset;
+    }
+    ///State transition - sets the `added_at` field to Set
+    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
+    impl<St: State> State for SetAddedAt<St> {
+        type AddedAt = Set<members::added_at>;
+        type Group = St::Group;
+        type Image = St::Image;
     }
     ///State transition - sets the `group` field to Set
     pub struct SetGroup<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGroup<St> {}
     impl<St: State> State for SetGroup<St> {
+        type AddedAt = St::AddedAt;
         type Group = Set<members::group>;
         type Image = St::Image;
-        type AddedAt = St::AddedAt;
     }
     ///State transition - sets the `image` field to Set
     pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetImage<St> {}
     impl<St: State> State for SetImage<St> {
-        type Group = St::Group;
-        type Image = Set<members::image>;
         type AddedAt = St::AddedAt;
-    }
-    ///State transition - sets the `added_at` field to Set
-    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
-    impl<St: State> State for SetAddedAt<St> {
         type Group = St::Group;
-        type Image = St::Image;
-        type AddedAt = Set<members::added_at>;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `added_at` field
+        pub struct added_at(());
         ///Marker type for the `group` field
         pub struct group(());
         ///Marker type for the `image` field
         pub struct image(());
-        ///Marker type for the `added_at` field
-        pub struct added_at(());
     }
 }
 
@@ -263,9 +263,9 @@ impl<S: BosStr, St: group_item_state::State> GroupItemBuilder<S, St> {
 impl<S: BosStr, St> GroupItemBuilder<S, St>
 where
     St: group_item_state::State,
+    St::AddedAt: group_item_state::IsSet,
     St::Group: group_item_state::IsSet,
     St::Image: group_item_state::IsSet,
-    St::AddedAt: group_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GroupItem<S> {
diff --git a/crates/jacquard-api/src/ch_indiemusi/alpha/recording.rs b/crates/jacquard-api/src/ch_indiemusi/alpha/recording.rs
index ea182576..6b5972a6 100644
--- a/crates/jacquard-api/src/ch_indiemusi/alpha/recording.rs
+++ b/crates/jacquard-api/src/ch_indiemusi/alpha/recording.rs
@@ -413,37 +413,37 @@ pub mod recording_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Artists;
         type Title;
+        type Artists;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Artists = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `artists` field to Set
-    pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtists<St> {}
-    impl<St: State> State for SetArtists<St> {
-        type Artists = Set<members::artists>;
-        type Title = St::Title;
+        type Artists = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Artists = St::Artists;
         type Title = Set<members::title>;
+        type Artists = St::Artists;
+    }
+    ///State transition - sets the `artists` field to Set
+    pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtists<St> {}
+    impl<St: State> State for SetArtists<St> {
+        type Title = St::Title;
+        type Artists = Set<members::artists>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artists` field
-        pub struct artists(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `artists` field
+        pub struct artists(());
     }
 }
 
@@ -592,8 +592,8 @@ where
 impl<S: BosStr, St> RecordingBuilder<S, St>
 where
     St: recording_state::State,
-    St::Artists: recording_state::IsSet,
     St::Title: recording_state::IsSet,
+    St::Artists: recording_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Recording<S> {
diff --git a/crates/jacquard-api/src/ch_indiemusi/alpha/release.rs b/crates/jacquard-api/src/ch_indiemusi/alpha/release.rs
index 1aea7607..1541dfb2 100644
--- a/crates/jacquard-api/src/ch_indiemusi/alpha/release.rs
+++ b/crates/jacquard-api/src/ch_indiemusi/alpha/release.rs
@@ -348,51 +348,51 @@ pub mod release_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Recordings;
         type Title;
         type Artists;
+        type Recordings;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Recordings = Unset;
         type Title = Unset;
         type Artists = Unset;
-    }
-    ///State transition - sets the `recordings` field to Set
-    pub struct SetRecordings<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecordings<St> {}
-    impl<St: State> State for SetRecordings<St> {
-        type Recordings = Set<members::recordings>;
-        type Title = St::Title;
-        type Artists = St::Artists;
+        type Recordings = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Recordings = St::Recordings;
         type Title = Set<members::title>;
         type Artists = St::Artists;
+        type Recordings = St::Recordings;
     }
     ///State transition - sets the `artists` field to Set
     pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetArtists<St> {}
     impl<St: State> State for SetArtists<St> {
-        type Recordings = St::Recordings;
         type Title = St::Title;
         type Artists = Set<members::artists>;
+        type Recordings = St::Recordings;
+    }
+    ///State transition - sets the `recordings` field to Set
+    pub struct SetRecordings<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecordings<St> {}
+    impl<St: State> State for SetRecordings<St> {
+        type Title = St::Title;
+        type Artists = St::Artists;
+        type Recordings = Set<members::recordings>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `recordings` field
-        pub struct recordings(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `artists` field
         pub struct artists(());
+        ///Marker type for the `recordings` field
+        pub struct recordings(());
     }
 }
 
@@ -527,9 +527,9 @@ where
 impl<S: BosStr, St> ReleaseBuilder<S, St>
 where
     St: release_state::State,
-    St::Recordings: release_state::IsSet,
     St::Title: release_state::IsSet,
     St::Artists: release_state::IsSet,
+    St::Recordings: release_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Release<S> {
diff --git a/crates/jacquard-api/src/ch_indiemusi/alpha/song.rs b/crates/jacquard-api/src/ch_indiemusi/alpha/song.rs
index b71fa331..8841298d 100644
--- a/crates/jacquard-api/src/ch_indiemusi/alpha/song.rs
+++ b/crates/jacquard-api/src/ch_indiemusi/alpha/song.rs
@@ -387,37 +387,37 @@ pub mod song_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type InterestedParties;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type InterestedParties = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type InterestedParties = St::InterestedParties;
+        type Title = Unset;
     }
     ///State transition - sets the `interested_parties` field to Set
     pub struct SetInterestedParties<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetInterestedParties<St> {}
     impl<St: State> State for SetInterestedParties<St> {
-        type Title = St::Title;
         type InterestedParties = Set<members::interested_parties>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type InterestedParties = St::InterestedParties;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `interested_parties` field
         pub struct interested_parties(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -500,8 +500,8 @@ where
 impl<S: BosStr, St> SongBuilder<S, St>
 where
     St: song_state::State,
-    St::Title: song_state::IsSet,
     St::InterestedParties: song_state::IsSet,
+    St::Title: song_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Song<S> {
diff --git a/crates/jacquard-api/src/ch_indiemusi/alpha/track.rs b/crates/jacquard-api/src/ch_indiemusi/alpha/track.rs
index b6e3eb9d..23d5b3c2 100644
--- a/crates/jacquard-api/src/ch_indiemusi/alpha/track.rs
+++ b/crates/jacquard-api/src/ch_indiemusi/alpha/track.rs
@@ -189,67 +189,67 @@ pub mod track_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type CreatedAt;
-        type AudioBlob;
         type EncryptedContentIv;
+        type Title;
+        type AudioBlob;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type CreatedAt = Unset;
-        type AudioBlob = Unset;
         type EncryptedContentIv = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type CreatedAt = St::CreatedAt;
-        type AudioBlob = St::AudioBlob;
-        type EncryptedContentIv = St::EncryptedContentIv;
+        type Title = Unset;
+        type AudioBlob = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Title = St::Title;
         type CreatedAt = Set<members::created_at>;
-        type AudioBlob = St::AudioBlob;
         type EncryptedContentIv = St::EncryptedContentIv;
-    }
-    ///State transition - sets the `audio_blob` field to Set
-    pub struct SetAudioBlob<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAudioBlob<St> {}
-    impl<St: State> State for SetAudioBlob<St> {
         type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-        type AudioBlob = Set<members::audio_blob>;
-        type EncryptedContentIv = St::EncryptedContentIv;
+        type AudioBlob = St::AudioBlob;
     }
     ///State transition - sets the `encrypted_content_iv` field to Set
     pub struct SetEncryptedContentIv<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEncryptedContentIv<St> {}
     impl<St: State> State for SetEncryptedContentIv<St> {
+        type CreatedAt = St::CreatedAt;
+        type EncryptedContentIv = Set<members::encrypted_content_iv>;
         type Title = St::Title;
+        type AudioBlob = St::AudioBlob;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
         type CreatedAt = St::CreatedAt;
+        type EncryptedContentIv = St::EncryptedContentIv;
+        type Title = Set<members::title>;
         type AudioBlob = St::AudioBlob;
-        type EncryptedContentIv = Set<members::encrypted_content_iv>;
+    }
+    ///State transition - sets the `audio_blob` field to Set
+    pub struct SetAudioBlob<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAudioBlob<St> {}
+    impl<St: State> State for SetAudioBlob<St> {
+        type CreatedAt = St::CreatedAt;
+        type EncryptedContentIv = St::EncryptedContentIv;
+        type Title = St::Title;
+        type AudioBlob = Set<members::audio_blob>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `audio_blob` field
-        pub struct audio_blob(());
         ///Marker type for the `encrypted_content_iv` field
         pub struct encrypted_content_iv(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `audio_blob` field
+        pub struct audio_blob(());
     }
 }
 
@@ -370,10 +370,10 @@ where
 impl<S: BosStr, St> TrackBuilder<S, St>
 where
     St: track_state::State,
-    St::Title: track_state::IsSet,
     St::CreatedAt: track_state::IsSet,
-    St::AudioBlob: track_state::IsSet,
     St::EncryptedContentIv: track_state::IsSet,
+    St::Title: track_state::IsSet,
+    St::AudioBlob: track_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Track<S> {
diff --git a/crates/jacquard-api/src/chat_bsky/actor.rs b/crates/jacquard-api/src/chat_bsky/actor.rs
index af02527e..c6f9fc38 100644
--- a/crates/jacquard-api/src/chat_bsky/actor.rs
+++ b/crates/jacquard-api/src/chat_bsky/actor.rs
@@ -105,37 +105,37 @@ pub mod profile_view_basic_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Did;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Did = St::Did;
+        type Handle = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Handle = St::Handle;
         type Did = Set<members::did>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -309,8 +309,8 @@ impl<S: BosStr, St: profile_view_basic_state::State> ProfileViewBasicBuilder<S,
 impl<S: BosStr, St> ProfileViewBasicBuilder<S, St>
 where
     St: profile_view_basic_state::State,
-    St::Handle: profile_view_basic_state::IsSet,
     St::Did: profile_view_basic_state::IsSet,
+    St::Handle: profile_view_basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileViewBasic<S> {
diff --git a/crates/jacquard-api/src/chat_bsky/convo.rs b/crates/jacquard-api/src/chat_bsky/convo.rs
index af4f493c..4e19ff2a 100644
--- a/crates/jacquard-api/src/chat_bsky/convo.rs
+++ b/crates/jacquard-api/src/chat_bsky/convo.rs
@@ -759,84 +759,84 @@ pub mod convo_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Members;
-        type Muted;
         type Id;
-        type UnreadCount;
         type Rev;
+        type Muted;
+        type UnreadCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Members = Unset;
-        type Muted = Unset;
         type Id = Unset;
-        type UnreadCount = Unset;
         type Rev = Unset;
+        type Muted = Unset;
+        type UnreadCount = Unset;
     }
     ///State transition - sets the `members` field to Set
     pub struct SetMembers<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMembers<St> {}
     impl<St: State> State for SetMembers<St> {
         type Members = Set<members::members>;
-        type Muted = St::Muted;
         type Id = St::Id;
-        type UnreadCount = St::UnreadCount;
         type Rev = St::Rev;
-    }
-    ///State transition - sets the `muted` field to Set
-    pub struct SetMuted<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMuted<St> {}
-    impl<St: State> State for SetMuted<St> {
-        type Members = St::Members;
-        type Muted = Set<members::muted>;
-        type Id = St::Id;
+        type Muted = St::Muted;
         type UnreadCount = St::UnreadCount;
-        type Rev = St::Rev;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
         type Members = St::Members;
-        type Muted = St::Muted;
         type Id = Set<members::id>;
-        type UnreadCount = St::UnreadCount;
         type Rev = St::Rev;
-    }
-    ///State transition - sets the `unread_count` field to Set
-    pub struct SetUnreadCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUnreadCount<St> {}
-    impl<St: State> State for SetUnreadCount<St> {
-        type Members = St::Members;
         type Muted = St::Muted;
-        type Id = St::Id;
-        type UnreadCount = Set<members::unread_count>;
-        type Rev = St::Rev;
+        type UnreadCount = St::UnreadCount;
     }
     ///State transition - sets the `rev` field to Set
     pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRev<St> {}
     impl<St: State> State for SetRev<St> {
         type Members = St::Members;
+        type Id = St::Id;
+        type Rev = Set<members::rev>;
         type Muted = St::Muted;
+        type UnreadCount = St::UnreadCount;
+    }
+    ///State transition - sets the `muted` field to Set
+    pub struct SetMuted<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMuted<St> {}
+    impl<St: State> State for SetMuted<St> {
+        type Members = St::Members;
         type Id = St::Id;
+        type Rev = St::Rev;
+        type Muted = Set<members::muted>;
         type UnreadCount = St::UnreadCount;
-        type Rev = Set<members::rev>;
+    }
+    ///State transition - sets the `unread_count` field to Set
+    pub struct SetUnreadCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUnreadCount<St> {}
+    impl<St: State> State for SetUnreadCount<St> {
+        type Members = St::Members;
+        type Id = St::Id;
+        type Rev = St::Rev;
+        type Muted = St::Muted;
+        type UnreadCount = Set<members::unread_count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `members` field
         pub struct members(());
-        ///Marker type for the `muted` field
-        pub struct muted(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `unread_count` field
-        pub struct unread_count(());
         ///Marker type for the `rev` field
         pub struct rev(());
+        ///Marker type for the `muted` field
+        pub struct muted(());
+        ///Marker type for the `unread_count` field
+        pub struct unread_count(());
     }
 }
 
@@ -1021,10 +1021,10 @@ impl<S: BosStr, St> ConvoViewBuilder<S, St>
 where
     St: convo_view_state::State,
     St::Members: convo_view_state::IsSet,
-    St::Muted: convo_view_state::IsSet,
     St::Id: convo_view_state::IsSet,
-    St::UnreadCount: convo_view_state::IsSet,
     St::Rev: convo_view_state::IsSet,
+    St::Muted: convo_view_state::IsSet,
+    St::UnreadCount: convo_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ConvoView<S> {
@@ -1761,67 +1761,67 @@ pub mod deleted_message_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Id;
         type Rev;
-        type SentAt;
         type Sender;
-        type Id;
+        type SentAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Id = Unset;
         type Rev = Unset;
-        type SentAt = Unset;
         type Sender = Unset;
-        type Id = Unset;
+        type SentAt = Unset;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
+        type Rev = St::Rev;
+        type Sender = St::Sender;
+        type SentAt = St::SentAt;
     }
     ///State transition - sets the `rev` field to Set
     pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRev<St> {}
     impl<St: State> State for SetRev<St> {
-        type Rev = Set<members::rev>;
-        type SentAt = St::SentAt;
-        type Sender = St::Sender;
         type Id = St::Id;
-    }
-    ///State transition - sets the `sent_at` field to Set
-    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSentAt<St> {}
-    impl<St: State> State for SetSentAt<St> {
-        type Rev = St::Rev;
-        type SentAt = Set<members::sent_at>;
+        type Rev = Set<members::rev>;
         type Sender = St::Sender;
-        type Id = St::Id;
+        type SentAt = St::SentAt;
     }
     ///State transition - sets the `sender` field to Set
     pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSender<St> {}
     impl<St: State> State for SetSender<St> {
+        type Id = St::Id;
         type Rev = St::Rev;
-        type SentAt = St::SentAt;
         type Sender = Set<members::sender>;
-        type Id = St::Id;
+        type SentAt = St::SentAt;
     }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
+    ///State transition - sets the `sent_at` field to Set
+    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSentAt<St> {}
+    impl<St: State> State for SetSentAt<St> {
+        type Id = St::Id;
         type Rev = St::Rev;
-        type SentAt = St::SentAt;
         type Sender = St::Sender;
-        type Id = Set<members::id>;
+        type SentAt = Set<members::sent_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `rev` field
         pub struct rev(());
-        ///Marker type for the `sent_at` field
-        pub struct sent_at(());
         ///Marker type for the `sender` field
         pub struct sender(());
-        ///Marker type for the `id` field
-        pub struct id(());
+        ///Marker type for the `sent_at` field
+        pub struct sent_at(());
     }
 }
 
@@ -1934,10 +1934,10 @@ where
 impl<S: BosStr, St> DeletedMessageViewBuilder<S, St>
 where
     St: deleted_message_view_state::State,
+    St::Id: deleted_message_view_state::IsSet,
     St::Rev: deleted_message_view_state::IsSet,
-    St::SentAt: deleted_message_view_state::IsSet,
     St::Sender: deleted_message_view_state::IsSet,
-    St::Id: deleted_message_view_state::IsSet,
+    St::SentAt: deleted_message_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeletedMessageView<S> {
@@ -1974,67 +1974,67 @@ pub mod log_add_reaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Rev;
         type Message;
-        type ConvoId;
         type Reaction;
+        type Rev;
+        type ConvoId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Rev = Unset;
         type Message = Unset;
-        type ConvoId = Unset;
         type Reaction = Unset;
-    }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
-        type Rev = Set<members::rev>;
-        type Message = St::Message;
-        type ConvoId = St::ConvoId;
-        type Reaction = St::Reaction;
+        type Rev = Unset;
+        type ConvoId = Unset;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type Rev = St::Rev;
         type Message = Set<members::message>;
-        type ConvoId = St::ConvoId;
         type Reaction = St::Reaction;
-    }
-    ///State transition - sets the `convo_id` field to Set
-    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetConvoId<St> {}
-    impl<St: State> State for SetConvoId<St> {
         type Rev = St::Rev;
-        type Message = St::Message;
-        type ConvoId = Set<members::convo_id>;
-        type Reaction = St::Reaction;
+        type ConvoId = St::ConvoId;
     }
     ///State transition - sets the `reaction` field to Set
     pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReaction<St> {}
     impl<St: State> State for SetReaction<St> {
+        type Message = St::Message;
+        type Reaction = Set<members::reaction>;
         type Rev = St::Rev;
+        type ConvoId = St::ConvoId;
+    }
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
         type Message = St::Message;
+        type Reaction = St::Reaction;
+        type Rev = Set<members::rev>;
         type ConvoId = St::ConvoId;
-        type Reaction = Set<members::reaction>;
+    }
+    ///State transition - sets the `convo_id` field to Set
+    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetConvoId<St> {}
+    impl<St: State> State for SetConvoId<St> {
+        type Message = St::Message;
+        type Reaction = St::Reaction;
+        type Rev = St::Rev;
+        type ConvoId = Set<members::convo_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `rev` field
-        pub struct rev(());
         ///Marker type for the `message` field
         pub struct message(());
-        ///Marker type for the `convo_id` field
-        pub struct convo_id(());
         ///Marker type for the `reaction` field
         pub struct reaction(());
+        ///Marker type for the `rev` field
+        pub struct rev(());
+        ///Marker type for the `convo_id` field
+        pub struct convo_id(());
     }
 }
 
@@ -2147,10 +2147,10 @@ where
 impl<S: BosStr, St> LogAddReactionBuilder<S, St>
 where
     St: log_add_reaction_state::State,
-    St::Rev: log_add_reaction_state::IsSet,
     St::Message: log_add_reaction_state::IsSet,
-    St::ConvoId: log_add_reaction_state::IsSet,
     St::Reaction: log_add_reaction_state::IsSet,
+    St::Rev: log_add_reaction_state::IsSet,
+    St::ConvoId: log_add_reaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LogAddReaction<S> {
@@ -2187,51 +2187,51 @@ pub mod log_create_message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Rev;
-        type ConvoId;
         type Message;
+        type ConvoId;
+        type Rev;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Rev = Unset;
-        type ConvoId = Unset;
         type Message = Unset;
+        type ConvoId = Unset;
+        type Rev = Unset;
     }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
-        type Rev = Set<members::rev>;
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type Message = Set<members::message>;
         type ConvoId = St::ConvoId;
-        type Message = St::Message;
+        type Rev = St::Rev;
     }
     ///State transition - sets the `convo_id` field to Set
     pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetConvoId<St> {}
     impl<St: State> State for SetConvoId<St> {
-        type Rev = St::Rev;
-        type ConvoId = Set<members::convo_id>;
         type Message = St::Message;
-    }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
+        type ConvoId = Set<members::convo_id>;
         type Rev = St::Rev;
+    }
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Message = St::Message;
         type ConvoId = St::ConvoId;
-        type Message = Set<members::message>;
+        type Rev = Set<members::rev>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `rev` field
-        pub struct rev(());
-        ///Marker type for the `convo_id` field
-        pub struct convo_id(());
         ///Marker type for the `message` field
         pub struct message(());
+        ///Marker type for the `convo_id` field
+        pub struct convo_id(());
+        ///Marker type for the `rev` field
+        pub struct rev(());
     }
 }
 
@@ -2320,9 +2320,9 @@ where
 impl<S: BosStr, St> LogCreateMessageBuilder<S, St>
 where
     St: log_create_message_state::State,
-    St::Rev: log_create_message_state::IsSet,
-    St::ConvoId: log_create_message_state::IsSet,
     St::Message: log_create_message_state::IsSet,
+    St::ConvoId: log_create_message_state::IsSet,
+    St::Rev: log_create_message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LogCreateMessage<S> {
@@ -2527,51 +2527,51 @@ pub mod log_read_message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Rev;
         type ConvoId;
         type Message;
-        type Rev;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Rev = Unset;
         type ConvoId = Unset;
         type Message = Unset;
-        type Rev = Unset;
+    }
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Rev = Set<members::rev>;
+        type ConvoId = St::ConvoId;
+        type Message = St::Message;
     }
     ///State transition - sets the `convo_id` field to Set
     pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetConvoId<St> {}
     impl<St: State> State for SetConvoId<St> {
+        type Rev = St::Rev;
         type ConvoId = Set<members::convo_id>;
         type Message = St::Message;
-        type Rev = St::Rev;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type ConvoId = St::ConvoId;
-        type Message = Set<members::message>;
         type Rev = St::Rev;
-    }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
         type ConvoId = St::ConvoId;
-        type Message = St::Message;
-        type Rev = Set<members::rev>;
+        type Message = Set<members::message>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `rev` field
+        pub struct rev(());
         ///Marker type for the `convo_id` field
         pub struct convo_id(());
         ///Marker type for the `message` field
         pub struct message(());
-        ///Marker type for the `rev` field
-        pub struct rev(());
     }
 }
 
@@ -2660,9 +2660,9 @@ where
 impl<S: BosStr, St> LogReadMessageBuilder<S, St>
 where
     St: log_read_message_state::State,
+    St::Rev: log_read_message_state::IsSet,
     St::ConvoId: log_read_message_state::IsSet,
     St::Message: log_read_message_state::IsSet,
-    St::Rev: log_read_message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LogReadMessage<S> {
@@ -2697,65 +2697,65 @@ pub mod log_remove_reaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ConvoId;
-        type Message;
         type Rev;
+        type Message;
+        type ConvoId;
         type Reaction;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ConvoId = Unset;
-        type Message = Unset;
         type Rev = Unset;
+        type Message = Unset;
+        type ConvoId = Unset;
         type Reaction = Unset;
     }
-    ///State transition - sets the `convo_id` field to Set
-    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetConvoId<St> {}
-    impl<St: State> State for SetConvoId<St> {
-        type ConvoId = Set<members::convo_id>;
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Rev = Set<members::rev>;
         type Message = St::Message;
-        type Rev = St::Rev;
+        type ConvoId = St::ConvoId;
         type Reaction = St::Reaction;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type ConvoId = St::ConvoId;
-        type Message = Set<members::message>;
         type Rev = St::Rev;
+        type Message = Set<members::message>;
+        type ConvoId = St::ConvoId;
         type Reaction = St::Reaction;
     }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
-        type ConvoId = St::ConvoId;
+    ///State transition - sets the `convo_id` field to Set
+    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetConvoId<St> {}
+    impl<St: State> State for SetConvoId<St> {
+        type Rev = St::Rev;
         type Message = St::Message;
-        type Rev = Set<members::rev>;
+        type ConvoId = Set<members::convo_id>;
         type Reaction = St::Reaction;
     }
     ///State transition - sets the `reaction` field to Set
     pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReaction<St> {}
     impl<St: State> State for SetReaction<St> {
-        type ConvoId = St::ConvoId;
-        type Message = St::Message;
         type Rev = St::Rev;
+        type Message = St::Message;
+        type ConvoId = St::ConvoId;
         type Reaction = Set<members::reaction>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `convo_id` field
-        pub struct convo_id(());
-        ///Marker type for the `message` field
-        pub struct message(());
         ///Marker type for the `rev` field
         pub struct rev(());
+        ///Marker type for the `message` field
+        pub struct message(());
+        ///Marker type for the `convo_id` field
+        pub struct convo_id(());
         ///Marker type for the `reaction` field
         pub struct reaction(());
     }
@@ -2870,9 +2870,9 @@ where
 impl<S: BosStr, St> LogRemoveReactionBuilder<S, St>
 where
     St: log_remove_reaction_state::State,
-    St::ConvoId: log_remove_reaction_state::IsSet,
-    St::Message: log_remove_reaction_state::IsSet,
     St::Rev: log_remove_reaction_state::IsSet,
+    St::Message: log_remove_reaction_state::IsSet,
+    St::ConvoId: log_remove_reaction_state::IsSet,
     St::Reaction: log_remove_reaction_state::IsSet,
 {
     /// Build the final struct.
@@ -3058,51 +3058,51 @@ pub mod message_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type MessageId;
         type ConvoId;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type MessageId = Unset;
         type ConvoId = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type MessageId = St::MessageId;
-        type ConvoId = St::ConvoId;
+        type Did = Unset;
     }
     ///State transition - sets the `message_id` field to Set
     pub struct SetMessageId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessageId<St> {}
     impl<St: State> State for SetMessageId<St> {
-        type Did = St::Did;
         type MessageId = Set<members::message_id>;
         type ConvoId = St::ConvoId;
+        type Did = St::Did;
     }
     ///State transition - sets the `convo_id` field to Set
     pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetConvoId<St> {}
     impl<St: State> State for SetConvoId<St> {
-        type Did = St::Did;
         type MessageId = St::MessageId;
         type ConvoId = Set<members::convo_id>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type MessageId = St::MessageId;
+        type ConvoId = St::ConvoId;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `message_id` field
         pub struct message_id(());
         ///Marker type for the `convo_id` field
         pub struct convo_id(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -3191,9 +3191,9 @@ where
 impl<S: BosStr, St> MessageRefBuilder<S, St>
 where
     St: message_ref_state::State,
-    St::Did: message_ref_state::IsSet,
     St::MessageId: message_ref_state::IsSet,
     St::ConvoId: message_ref_state::IsSet,
+    St::Did: message_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MessageRef<S> {
@@ -3228,85 +3228,85 @@ pub mod message_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type SentAt;
-        type Id;
+        type Rev;
         type Text;
+        type SentAt;
         type Sender;
-        type Rev;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type SentAt = Unset;
-        type Id = Unset;
+        type Rev = Unset;
         type Text = Unset;
+        type SentAt = Unset;
         type Sender = Unset;
-        type Rev = Unset;
+        type Id = Unset;
     }
-    ///State transition - sets the `sent_at` field to Set
-    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSentAt<St> {}
-    impl<St: State> State for SetSentAt<St> {
-        type SentAt = Set<members::sent_at>;
-        type Id = St::Id;
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Rev = Set<members::rev>;
         type Text = St::Text;
-        type Sender = St::Sender;
-        type Rev = St::Rev;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
         type SentAt = St::SentAt;
-        type Id = Set<members::id>;
-        type Text = St::Text;
         type Sender = St::Sender;
-        type Rev = St::Rev;
+        type Id = St::Id;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
-        type SentAt = St::SentAt;
-        type Id = St::Id;
+        type Rev = St::Rev;
         type Text = Set<members::text>;
+        type SentAt = St::SentAt;
         type Sender = St::Sender;
+        type Id = St::Id;
+    }
+    ///State transition - sets the `sent_at` field to Set
+    pub struct SetSentAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSentAt<St> {}
+    impl<St: State> State for SetSentAt<St> {
         type Rev = St::Rev;
+        type Text = St::Text;
+        type SentAt = Set<members::sent_at>;
+        type Sender = St::Sender;
+        type Id = St::Id;
     }
     ///State transition - sets the `sender` field to Set
     pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSender<St> {}
     impl<St: State> State for SetSender<St> {
-        type SentAt = St::SentAt;
-        type Id = St::Id;
-        type Text = St::Text;
-        type Sender = Set<members::sender>;
         type Rev = St::Rev;
-    }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
+        type Text = St::Text;
         type SentAt = St::SentAt;
+        type Sender = Set<members::sender>;
         type Id = St::Id;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Rev = St::Rev;
         type Text = St::Text;
+        type SentAt = St::SentAt;
         type Sender = St::Sender;
-        type Rev = Set<members::rev>;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `sent_at` field
-        pub struct sent_at(());
-        ///Marker type for the `id` field
-        pub struct id(());
+        ///Marker type for the `rev` field
+        pub struct rev(());
         ///Marker type for the `text` field
         pub struct text(());
+        ///Marker type for the `sent_at` field
+        pub struct sent_at(());
         ///Marker type for the `sender` field
         pub struct sender(());
-        ///Marker type for the `rev` field
-        pub struct rev(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -3487,11 +3487,11 @@ where
 impl<S: BosStr, St> MessageViewBuilder<S, St>
 where
     St: message_view_state::State,
-    St::SentAt: message_view_state::IsSet,
-    St::Id: message_view_state::IsSet,
+    St::Rev: message_view_state::IsSet,
     St::Text: message_view_state::IsSet,
+    St::SentAt: message_view_state::IsSet,
     St::Sender: message_view_state::IsSet,
-    St::Rev: message_view_state::IsSet,
+    St::Id: message_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MessageView<S> {
@@ -3636,51 +3636,51 @@ pub mod reaction_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Value;
         type Sender;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Value = Unset;
         type Sender = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Value = St::Value;
-        type Sender = St::Sender;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type CreatedAt = St::CreatedAt;
         type Value = Set<members::value>;
         type Sender = St::Sender;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `sender` field to Set
     pub struct SetSender<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSender<St> {}
     impl<St: State> State for SetSender<St> {
-        type CreatedAt = St::CreatedAt;
         type Value = St::Value;
         type Sender = Set<members::sender>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Value = St::Value;
+        type Sender = St::Sender;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `value` field
         pub struct value(());
         ///Marker type for the `sender` field
         pub struct sender(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -3769,9 +3769,9 @@ where
 impl<S: BosStr, St> ReactionViewBuilder<S, St>
 where
     St: reaction_view_state::State,
-    St::CreatedAt: reaction_view_state::IsSet,
     St::Value: reaction_view_state::IsSet,
     St::Sender: reaction_view_state::IsSet,
+    St::CreatedAt: reaction_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReactionView<S> {
diff --git a/crates/jacquard-api/src/chat_bsky/convo/send_message.rs b/crates/jacquard-api/src/chat_bsky/convo/send_message.rs
index 4ca03030..f809b344 100644
--- a/crates/jacquard-api/src/chat_bsky/convo/send_message.rs
+++ b/crates/jacquard-api/src/chat_bsky/convo/send_message.rs
@@ -75,37 +75,37 @@ pub mod send_message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ConvoId;
         type Message;
+        type ConvoId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ConvoId = Unset;
         type Message = Unset;
-    }
-    ///State transition - sets the `convo_id` field to Set
-    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetConvoId<St> {}
-    impl<St: State> State for SetConvoId<St> {
-        type ConvoId = Set<members::convo_id>;
-        type Message = St::Message;
+        type ConvoId = Unset;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type ConvoId = St::ConvoId;
         type Message = Set<members::message>;
+        type ConvoId = St::ConvoId;
+    }
+    ///State transition - sets the `convo_id` field to Set
+    pub struct SetConvoId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetConvoId<St> {}
+    impl<St: State> State for SetConvoId<St> {
+        type Message = St::Message;
+        type ConvoId = Set<members::convo_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `convo_id` field
-        pub struct convo_id(());
         ///Marker type for the `message` field
         pub struct message(());
+        ///Marker type for the `convo_id` field
+        pub struct convo_id(());
     }
 }
 
@@ -175,8 +175,8 @@ where
 impl<S: BosStr, St> SendMessageBuilder<S, St>
 where
     St: send_message_state::State,
-    St::ConvoId: send_message_state::IsSet,
     St::Message: send_message_state::IsSet,
+    St::ConvoId: send_message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SendMessage<S> {
diff --git a/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs b/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs
index 6c5d5a4b..9fb02527 100644
--- a/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs
+++ b/crates/jacquard-api/src/chat_bsky/moderation/get_actor_metadata.rs
@@ -193,67 +193,67 @@ pub mod metadata_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MessagesSent;
-        type Convos;
         type MessagesReceived;
+        type MessagesSent;
         type ConvosStarted;
+        type Convos;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MessagesSent = Unset;
-        type Convos = Unset;
         type MessagesReceived = Unset;
+        type MessagesSent = Unset;
         type ConvosStarted = Unset;
-    }
-    ///State transition - sets the `messages_sent` field to Set
-    pub struct SetMessagesSent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessagesSent<St> {}
-    impl<St: State> State for SetMessagesSent<St> {
-        type MessagesSent = Set<members::messages_sent>;
-        type Convos = St::Convos;
-        type MessagesReceived = St::MessagesReceived;
-        type ConvosStarted = St::ConvosStarted;
-    }
-    ///State transition - sets the `convos` field to Set
-    pub struct SetConvos<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetConvos<St> {}
-    impl<St: State> State for SetConvos<St> {
-        type MessagesSent = St::MessagesSent;
-        type Convos = Set<members::convos>;
-        type MessagesReceived = St::MessagesReceived;
-        type ConvosStarted = St::ConvosStarted;
+        type Convos = Unset;
     }
     ///State transition - sets the `messages_received` field to Set
     pub struct SetMessagesReceived<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessagesReceived<St> {}
     impl<St: State> State for SetMessagesReceived<St> {
+        type MessagesReceived = Set<members::messages_received>;
         type MessagesSent = St::MessagesSent;
+        type ConvosStarted = St::ConvosStarted;
         type Convos = St::Convos;
-        type MessagesReceived = Set<members::messages_received>;
+    }
+    ///State transition - sets the `messages_sent` field to Set
+    pub struct SetMessagesSent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessagesSent<St> {}
+    impl<St: State> State for SetMessagesSent<St> {
+        type MessagesReceived = St::MessagesReceived;
+        type MessagesSent = Set<members::messages_sent>;
         type ConvosStarted = St::ConvosStarted;
+        type Convos = St::Convos;
     }
     ///State transition - sets the `convos_started` field to Set
     pub struct SetConvosStarted<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetConvosStarted<St> {}
     impl<St: State> State for SetConvosStarted<St> {
+        type MessagesReceived = St::MessagesReceived;
         type MessagesSent = St::MessagesSent;
+        type ConvosStarted = Set<members::convos_started>;
         type Convos = St::Convos;
+    }
+    ///State transition - sets the `convos` field to Set
+    pub struct SetConvos<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetConvos<St> {}
+    impl<St: State> State for SetConvos<St> {
         type MessagesReceived = St::MessagesReceived;
-        type ConvosStarted = Set<members::convos_started>;
+        type MessagesSent = St::MessagesSent;
+        type ConvosStarted = St::ConvosStarted;
+        type Convos = Set<members::convos>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `messages_sent` field
-        pub struct messages_sent(());
-        ///Marker type for the `convos` field
-        pub struct convos(());
         ///Marker type for the `messages_received` field
         pub struct messages_received(());
+        ///Marker type for the `messages_sent` field
+        pub struct messages_sent(());
         ///Marker type for the `convos_started` field
         pub struct convos_started(());
+        ///Marker type for the `convos` field
+        pub struct convos(());
     }
 }
 
@@ -361,10 +361,10 @@ where
 impl<S: BosStr, St> MetadataBuilder<S, St>
 where
     St: metadata_state::State,
-    St::MessagesSent: metadata_state::IsSet,
-    St::Convos: metadata_state::IsSet,
     St::MessagesReceived: metadata_state::IsSet,
+    St::MessagesSent: metadata_state::IsSet,
     St::ConvosStarted: metadata_state::IsSet,
+    St::Convos: metadata_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Metadata<S> {
diff --git a/crates/jacquard-api/src/club_stellz/evm/address_control.rs b/crates/jacquard-api/src/club_stellz/evm/address_control.rs
index 9ae2da32..bad3139b 100644
--- a/crates/jacquard-api/src/club_stellz/evm/address_control.rs
+++ b/crates/jacquard-api/src/club_stellz/evm/address_control.rs
@@ -522,149 +522,149 @@ pub mod siwe_message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Domain;
         type Address;
-        type Uri;
-        type Version;
-        type ChainId;
         type Nonce;
+        type ChainId;
         type IssuedAt;
-        type Domain;
+        type Uri;
+        type Version;
         type Statement;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Domain = Unset;
         type Address = Unset;
-        type Uri = Unset;
-        type Version = Unset;
-        type ChainId = Unset;
         type Nonce = Unset;
+        type ChainId = Unset;
         type IssuedAt = Unset;
-        type Domain = Unset;
+        type Uri = Unset;
+        type Version = Unset;
         type Statement = Unset;
     }
+    ///State transition - sets the `domain` field to Set
+    pub struct SetDomain<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDomain<St> {}
+    impl<St: State> State for SetDomain<St> {
+        type Domain = Set<members::domain>;
+        type Address = St::Address;
+        type Nonce = St::Nonce;
+        type ChainId = St::ChainId;
+        type IssuedAt = St::IssuedAt;
+        type Uri = St::Uri;
+        type Version = St::Version;
+        type Statement = St::Statement;
+    }
     ///State transition - sets the `address` field to Set
     pub struct SetAddress<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAddress<St> {}
     impl<St: State> State for SetAddress<St> {
+        type Domain = St::Domain;
         type Address = Set<members::address>;
-        type Uri = St::Uri;
-        type Version = St::Version;
-        type ChainId = St::ChainId;
         type Nonce = St::Nonce;
-        type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
-        type Statement = St::Statement;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Address = St::Address;
-        type Uri = Set<members::uri>;
-        type Version = St::Version;
         type ChainId = St::ChainId;
-        type Nonce = St::Nonce;
         type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
+        type Uri = St::Uri;
+        type Version = St::Version;
         type Statement = St::Statement;
     }
-    ///State transition - sets the `version` field to Set
-    pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVersion<St> {}
-    impl<St: State> State for SetVersion<St> {
+    ///State transition - sets the `nonce` field to Set
+    pub struct SetNonce<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNonce<St> {}
+    impl<St: State> State for SetNonce<St> {
+        type Domain = St::Domain;
         type Address = St::Address;
-        type Uri = St::Uri;
-        type Version = Set<members::version>;
+        type Nonce = Set<members::nonce>;
         type ChainId = St::ChainId;
-        type Nonce = St::Nonce;
         type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
+        type Uri = St::Uri;
+        type Version = St::Version;
         type Statement = St::Statement;
     }
     ///State transition - sets the `chain_id` field to Set
     pub struct SetChainId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetChainId<St> {}
     impl<St: State> State for SetChainId<St> {
+        type Domain = St::Domain;
         type Address = St::Address;
-        type Uri = St::Uri;
-        type Version = St::Version;
-        type ChainId = Set<members::chain_id>;
         type Nonce = St::Nonce;
+        type ChainId = Set<members::chain_id>;
         type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
-        type Statement = St::Statement;
-    }
-    ///State transition - sets the `nonce` field to Set
-    pub struct SetNonce<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNonce<St> {}
-    impl<St: State> State for SetNonce<St> {
-        type Address = St::Address;
         type Uri = St::Uri;
         type Version = St::Version;
-        type ChainId = St::ChainId;
-        type Nonce = Set<members::nonce>;
-        type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
         type Statement = St::Statement;
     }
     ///State transition - sets the `issued_at` field to Set
     pub struct SetIssuedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIssuedAt<St> {}
     impl<St: State> State for SetIssuedAt<St> {
+        type Domain = St::Domain;
         type Address = St::Address;
-        type Uri = St::Uri;
-        type Version = St::Version;
-        type ChainId = St::ChainId;
         type Nonce = St::Nonce;
+        type ChainId = St::ChainId;
         type IssuedAt = Set<members::issued_at>;
-        type Domain = St::Domain;
+        type Uri = St::Uri;
+        type Version = St::Version;
         type Statement = St::Statement;
     }
-    ///State transition - sets the `domain` field to Set
-    pub struct SetDomain<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDomain<St> {}
-    impl<St: State> State for SetDomain<St> {
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Domain = St::Domain;
         type Address = St::Address;
-        type Uri = St::Uri;
-        type Version = St::Version;
+        type Nonce = St::Nonce;
         type ChainId = St::ChainId;
+        type IssuedAt = St::IssuedAt;
+        type Uri = Set<members::uri>;
+        type Version = St::Version;
+        type Statement = St::Statement;
+    }
+    ///State transition - sets the `version` field to Set
+    pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVersion<St> {}
+    impl<St: State> State for SetVersion<St> {
+        type Domain = St::Domain;
+        type Address = St::Address;
         type Nonce = St::Nonce;
+        type ChainId = St::ChainId;
         type IssuedAt = St::IssuedAt;
-        type Domain = Set<members::domain>;
+        type Uri = St::Uri;
+        type Version = Set<members::version>;
         type Statement = St::Statement;
     }
     ///State transition - sets the `statement` field to Set
     pub struct SetStatement<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatement<St> {}
     impl<St: State> State for SetStatement<St> {
+        type Domain = St::Domain;
         type Address = St::Address;
-        type Uri = St::Uri;
-        type Version = St::Version;
-        type ChainId = St::ChainId;
         type Nonce = St::Nonce;
+        type ChainId = St::ChainId;
         type IssuedAt = St::IssuedAt;
-        type Domain = St::Domain;
+        type Uri = St::Uri;
+        type Version = St::Version;
         type Statement = Set<members::statement>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `domain` field
+        pub struct domain(());
         ///Marker type for the `address` field
         pub struct address(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `version` field
-        pub struct version(());
-        ///Marker type for the `chain_id` field
-        pub struct chain_id(());
         ///Marker type for the `nonce` field
         pub struct nonce(());
+        ///Marker type for the `chain_id` field
+        pub struct chain_id(());
         ///Marker type for the `issued_at` field
         pub struct issued_at(());
-        ///Marker type for the `domain` field
-        pub struct domain(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `version` field
+        pub struct version(());
         ///Marker type for the `statement` field
         pub struct statement(());
     }
@@ -859,13 +859,13 @@ where
 impl<S: BosStr, St> SiweMessageBuilder<S, St>
 where
     St: siwe_message_state::State,
+    St::Domain: siwe_message_state::IsSet,
     St::Address: siwe_message_state::IsSet,
-    St::Uri: siwe_message_state::IsSet,
-    St::Version: siwe_message_state::IsSet,
-    St::ChainId: siwe_message_state::IsSet,
     St::Nonce: siwe_message_state::IsSet,
+    St::ChainId: siwe_message_state::IsSet,
     St::IssuedAt: siwe_message_state::IsSet,
-    St::Domain: siwe_message_state::IsSet,
+    St::Uri: siwe_message_state::IsSet,
+    St::Version: siwe_message_state::IsSet,
     St::Statement: siwe_message_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/com__5jiji/test/publish_video.rs b/crates/jacquard-api/src/com__5jiji/test/publish_video.rs
index 817870cc..81f5a7b2 100644
--- a/crates/jacquard-api/src/com__5jiji/test/publish_video.rs
+++ b/crates/jacquard-api/src/com__5jiji/test/publish_video.rs
@@ -90,7 +90,7 @@ impl jacquard_common::xrpc::XrpcRequest for PublishVideo {
     type Response = PublishVideoResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/com__5jiji/test/videos.rs b/crates/jacquard-api/src/com__5jiji/test/videos.rs
index b65d9420..48c3eccc 100644
--- a/crates/jacquard-api/src/com__5jiji/test/videos.rs
+++ b/crates/jacquard-api/src/com__5jiji/test/videos.rs
@@ -126,51 +126,51 @@ pub mod videos_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Id;
         type Creator;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Id = Unset;
         type Creator = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Id = St::Id;
-        type Creator = St::Creator;
+        type Title = Unset;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Title = St::Title;
         type Id = Set<members::id>;
         type Creator = St::Creator;
+        type Title = St::Title;
     }
     ///State transition - sets the `creator` field to Set
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
-        type Title = St::Title;
         type Id = St::Id;
         type Creator = Set<members::creator>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Id = St::Id;
+        type Creator = St::Creator;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `id` field
         pub struct id(());
         ///Marker type for the `creator` field
         pub struct creator(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -259,9 +259,9 @@ where
 impl<S: BosStr, St> VideosBuilder<S, St>
 where
     St: videos_state::State,
-    St::Title: videos_state::IsSet,
     St::Id: videos_state::IsSet,
     St::Creator: videos_state::IsSet,
+    St::Title: videos_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Videos<S> {
diff --git a/crates/jacquard-api/src/com_atproto/admin/send_email.rs b/crates/jacquard-api/src/com_atproto/admin/send_email.rs
index 160ea6df..b664007c 100644
--- a/crates/jacquard-api/src/com_atproto/admin/send_email.rs
+++ b/crates/jacquard-api/src/com_atproto/admin/send_email.rs
@@ -80,50 +80,50 @@ pub mod send_email_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type SenderDid;
-        type RecipientDid;
         type Content;
+        type RecipientDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type SenderDid = Unset;
-        type RecipientDid = Unset;
         type Content = Unset;
+        type RecipientDid = Unset;
     }
     ///State transition - sets the `sender_did` field to Set
     pub struct SetSenderDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSenderDid<St> {}
     impl<St: State> State for SetSenderDid<St> {
         type SenderDid = Set<members::sender_did>;
-        type RecipientDid = St::RecipientDid;
-        type Content = St::Content;
-    }
-    ///State transition - sets the `recipient_did` field to Set
-    pub struct SetRecipientDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecipientDid<St> {}
-    impl<St: State> State for SetRecipientDid<St> {
-        type SenderDid = St::SenderDid;
-        type RecipientDid = Set<members::recipient_did>;
         type Content = St::Content;
+        type RecipientDid = St::RecipientDid;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
         type SenderDid = St::SenderDid;
-        type RecipientDid = St::RecipientDid;
         type Content = Set<members::content>;
+        type RecipientDid = St::RecipientDid;
+    }
+    ///State transition - sets the `recipient_did` field to Set
+    pub struct SetRecipientDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecipientDid<St> {}
+    impl<St: State> State for SetRecipientDid<St> {
+        type SenderDid = St::SenderDid;
+        type Content = St::Content;
+        type RecipientDid = Set<members::recipient_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `sender_did` field
         pub struct sender_did(());
-        ///Marker type for the `recipient_did` field
-        pub struct recipient_did(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `recipient_did` field
+        pub struct recipient_did(());
     }
 }
 
@@ -239,8 +239,8 @@ impl<S: BosStr, St> SendEmailBuilder<S, St>
 where
     St: send_email_state::State,
     St::SenderDid: send_email_state::IsSet,
-    St::RecipientDid: send_email_state::IsSet,
     St::Content: send_email_state::IsSet,
+    St::RecipientDid: send_email_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SendEmail<S> {
diff --git a/crates/jacquard-api/src/com_atproto/admin/update_account_password.rs b/crates/jacquard-api/src/com_atproto/admin/update_account_password.rs
index 6961ad83..479b10eb 100644
--- a/crates/jacquard-api/src/com_atproto/admin/update_account_password.rs
+++ b/crates/jacquard-api/src/com_atproto/admin/update_account_password.rs
@@ -64,37 +64,37 @@ pub mod update_account_password_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Password;
         type Did;
+        type Password;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Password = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `password` field to Set
-    pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPassword<St> {}
-    impl<St: State> State for SetPassword<St> {
-        type Password = Set<members::password>;
-        type Did = St::Did;
+        type Password = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Password = St::Password;
         type Did = Set<members::did>;
+        type Password = St::Password;
+    }
+    ///State transition - sets the `password` field to Set
+    pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPassword<St> {}
+    impl<St: State> State for SetPassword<St> {
+        type Did = St::Did;
+        type Password = Set<members::password>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `password` field
-        pub struct password(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `password` field
+        pub struct password(());
     }
 }
 
@@ -173,8 +173,8 @@ where
 impl<S: BosStr, St> UpdateAccountPasswordBuilder<S, St>
 where
     St: update_account_password_state::State,
-    St::Password: update_account_password_state::IsSet,
     St::Did: update_account_password_state::IsSet,
+    St::Password: update_account_password_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateAccountPassword<S> {
diff --git a/crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs b/crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs
index 3c1cead3..918f6645 100644
--- a/crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs
+++ b/crates/jacquard-api/src/com_atproto/admin/update_account_signing_key.rs
@@ -65,37 +65,37 @@ pub mod update_account_signing_key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type SigningKey;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type SigningKey = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type SigningKey = St::SigningKey;
+        type Did = Unset;
     }
     ///State transition - sets the `signing_key` field to Set
     pub struct SetSigningKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSigningKey<St> {}
     impl<St: State> State for SetSigningKey<St> {
-        type Did = St::Did;
         type SigningKey = Set<members::signing_key>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type SigningKey = St::SigningKey;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `signing_key` field
         pub struct signing_key(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -179,8 +179,8 @@ where
 impl<S: BosStr, St> UpdateAccountSigningKeyBuilder<S, St>
 where
     St: update_account_signing_key_state::State,
-    St::Did: update_account_signing_key_state::IsSet,
     St::SigningKey: update_account_signing_key_state::IsSet,
+    St::Did: update_account_signing_key_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateAccountSigningKey<S> {
diff --git a/crates/jacquard-api/src/com_atproto/identity.rs b/crates/jacquard-api/src/com_atproto/identity.rs
index 25fc8bb7..8d6dde9b 100644
--- a/crates/jacquard-api/src/com_atproto/identity.rs
+++ b/crates/jacquard-api/src/com_atproto/identity.rs
@@ -73,49 +73,49 @@ pub mod identity_info_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Handle;
+        type Did;
         type DidDoc;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Handle = Unset;
+        type Did = Unset;
         type DidDoc = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Handle = St::Handle;
-        type DidDoc = St::DidDoc;
-    }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
         type Handle = Set<members::handle>;
+        type Did = St::Did;
+        type DidDoc = St::DidDoc;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Handle = St::Handle;
+        type Did = Set<members::did>;
         type DidDoc = St::DidDoc;
     }
     ///State transition - sets the `did_doc` field to Set
     pub struct SetDidDoc<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDidDoc<St> {}
     impl<St: State> State for SetDidDoc<St> {
-        type Did = St::Did;
         type Handle = St::Handle;
+        type Did = St::Did;
         type DidDoc = Set<members::did_doc>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `did_doc` field
         pub struct did_doc(());
     }
@@ -206,8 +206,8 @@ where
 impl<S: BosStr, St> IdentityInfoBuilder<S, St>
 where
     St: identity_info_state::State,
-    St::Did: identity_info_state::IsSet,
     St::Handle: identity_info_state::IsSet,
+    St::Did: identity_info_state::IsSet,
     St::DidDoc: identity_info_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/com_atproto/label.rs b/crates/jacquard-api/src/com_atproto/label.rs
index 6b894d92..0f5e9236 100644
--- a/crates/jacquard-api/src/com_atproto/label.rs
+++ b/crates/jacquard-api/src/com_atproto/label.rs
@@ -674,65 +674,65 @@ pub mod label_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Cts;
         type Val;
         type Uri;
-        type Cts;
         type Src;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Cts = Unset;
         type Val = Unset;
         type Uri = Unset;
-        type Cts = Unset;
         type Src = Unset;
     }
+    ///State transition - sets the `cts` field to Set
+    pub struct SetCts<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCts<St> {}
+    impl<St: State> State for SetCts<St> {
+        type Cts = Set<members::cts>;
+        type Val = St::Val;
+        type Uri = St::Uri;
+        type Src = St::Src;
+    }
     ///State transition - sets the `val` field to Set
     pub struct SetVal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVal<St> {}
     impl<St: State> State for SetVal<St> {
+        type Cts = St::Cts;
         type Val = Set<members::val>;
         type Uri = St::Uri;
-        type Cts = St::Cts;
         type Src = St::Src;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Val = St::Val;
-        type Uri = Set<members::uri>;
         type Cts = St::Cts;
-        type Src = St::Src;
-    }
-    ///State transition - sets the `cts` field to Set
-    pub struct SetCts<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCts<St> {}
-    impl<St: State> State for SetCts<St> {
         type Val = St::Val;
-        type Uri = St::Uri;
-        type Cts = Set<members::cts>;
+        type Uri = Set<members::uri>;
         type Src = St::Src;
     }
     ///State transition - sets the `src` field to Set
     pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSrc<St> {}
     impl<St: State> State for SetSrc<St> {
+        type Cts = St::Cts;
         type Val = St::Val;
         type Uri = St::Uri;
-        type Cts = St::Cts;
         type Src = Set<members::src>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `cts` field
+        pub struct cts(());
         ///Marker type for the `val` field
         pub struct val(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `cts` field
-        pub struct cts(());
         ///Marker type for the `src` field
         pub struct src(());
     }
@@ -917,9 +917,9 @@ impl<S: BosStr, St: label_state::State> LabelBuilder<S, St> {
 impl<S: BosStr, St> LabelBuilder<S, St>
 where
     St: label_state::State,
+    St::Cts: label_state::IsSet,
     St::Val: label_state::IsSet,
     St::Uri: label_state::IsSet,
-    St::Cts: label_state::IsSet,
     St::Src: label_state::IsSet,
 {
     /// Build the final struct.
@@ -1292,67 +1292,67 @@ pub mod label_value_definition_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Blurs;
+        type Identifier;
         type Locales;
         type Severity;
-        type Identifier;
-        type Blurs;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Blurs = Unset;
+        type Identifier = Unset;
         type Locales = Unset;
         type Severity = Unset;
-        type Identifier = Unset;
-        type Blurs = Unset;
+    }
+    ///State transition - sets the `blurs` field to Set
+    pub struct SetBlurs<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlurs<St> {}
+    impl<St: State> State for SetBlurs<St> {
+        type Blurs = Set<members::blurs>;
+        type Identifier = St::Identifier;
+        type Locales = St::Locales;
+        type Severity = St::Severity;
+    }
+    ///State transition - sets the `identifier` field to Set
+    pub struct SetIdentifier<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIdentifier<St> {}
+    impl<St: State> State for SetIdentifier<St> {
+        type Blurs = St::Blurs;
+        type Identifier = Set<members::identifier>;
+        type Locales = St::Locales;
+        type Severity = St::Severity;
     }
     ///State transition - sets the `locales` field to Set
     pub struct SetLocales<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLocales<St> {}
     impl<St: State> State for SetLocales<St> {
+        type Blurs = St::Blurs;
+        type Identifier = St::Identifier;
         type Locales = Set<members::locales>;
         type Severity = St::Severity;
-        type Identifier = St::Identifier;
-        type Blurs = St::Blurs;
     }
     ///State transition - sets the `severity` field to Set
     pub struct SetSeverity<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeverity<St> {}
     impl<St: State> State for SetSeverity<St> {
-        type Locales = St::Locales;
-        type Severity = Set<members::severity>;
-        type Identifier = St::Identifier;
-        type Blurs = St::Blurs;
-    }
-    ///State transition - sets the `identifier` field to Set
-    pub struct SetIdentifier<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIdentifier<St> {}
-    impl<St: State> State for SetIdentifier<St> {
-        type Locales = St::Locales;
-        type Severity = St::Severity;
-        type Identifier = Set<members::identifier>;
         type Blurs = St::Blurs;
-    }
-    ///State transition - sets the `blurs` field to Set
-    pub struct SetBlurs<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlurs<St> {}
-    impl<St: State> State for SetBlurs<St> {
-        type Locales = St::Locales;
-        type Severity = St::Severity;
         type Identifier = St::Identifier;
-        type Blurs = Set<members::blurs>;
+        type Locales = St::Locales;
+        type Severity = Set<members::severity>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `blurs` field
+        pub struct blurs(());
+        ///Marker type for the `identifier` field
+        pub struct identifier(());
         ///Marker type for the `locales` field
         pub struct locales(());
         ///Marker type for the `severity` field
         pub struct severity(());
-        ///Marker type for the `identifier` field
-        pub struct identifier(());
-        ///Marker type for the `blurs` field
-        pub struct blurs(());
     }
 }
 
@@ -1511,10 +1511,10 @@ where
 impl<S: BosStr, St> LabelValueDefinitionBuilder<S, St>
 where
     St: label_value_definition_state::State,
+    St::Blurs: label_value_definition_state::IsSet,
+    St::Identifier: label_value_definition_state::IsSet,
     St::Locales: label_value_definition_state::IsSet,
     St::Severity: label_value_definition_state::IsSet,
-    St::Identifier: label_value_definition_state::IsSet,
-    St::Blurs: label_value_definition_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LabelValueDefinition<S> {
@@ -1555,51 +1555,51 @@ pub mod label_value_definition_strings_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type Lang;
         type Description;
+        type Lang;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type Lang = Unset;
         type Description = Unset;
+        type Lang = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Description = Set<members::description>;
         type Lang = St::Lang;
-        type Description = St::Description;
+        type Name = St::Name;
     }
     ///State transition - sets the `lang` field to Set
     pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLang<St> {}
     impl<St: State> State for SetLang<St> {
-        type Name = St::Name;
-        type Lang = Set<members::lang>;
         type Description = St::Description;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
+        type Lang = Set<members::lang>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Description = St::Description;
         type Lang = St::Lang;
-        type Description = Set<members::description>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `lang` field
-        pub struct lang(());
         ///Marker type for the `description` field
         pub struct description(());
+        ///Marker type for the `lang` field
+        pub struct lang(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -1705,9 +1705,9 @@ where
 impl<S: BosStr, St> LabelValueDefinitionStringsBuilder<S, St>
 where
     St: label_value_definition_strings_state::State,
-    St::Name: label_value_definition_strings_state::IsSet,
-    St::Lang: label_value_definition_strings_state::IsSet,
     St::Description: label_value_definition_strings_state::IsSet,
+    St::Lang: label_value_definition_strings_state::IsSet,
+    St::Name: label_value_definition_strings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LabelValueDefinitionStrings<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs b/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs
index bbfe4560..4d67b93b 100644
--- a/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/apply_writes.rs
@@ -923,37 +923,37 @@ pub mod create_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Cid;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
+        type Uri = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
         type Cid = Set<members::cid>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -1042,8 +1042,8 @@ impl<S: BosStr, St: create_result_state::State> CreateResultBuilder<S, St> {
 impl<S: BosStr, St> CreateResultBuilder<S, St>
 where
     St: create_result_state::State,
-    St::Uri: create_result_state::IsSet,
     St::Cid: create_result_state::IsSet,
+    St::Uri: create_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CreateResult<S> {
@@ -1209,37 +1209,37 @@ pub mod apply_writes_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Writes;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Writes = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Writes = St::Writes;
+        type Repo = Unset;
     }
     ///State transition - sets the `writes` field to Set
     pub struct SetWrites<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWrites<St> {}
     impl<St: State> State for SetWrites<St> {
-        type Repo = St::Repo;
         type Writes = Set<members::writes>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Writes = St::Writes;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `writes` field
         pub struct writes(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -1340,8 +1340,8 @@ where
 impl<S: BosStr, St> ApplyWritesBuilder<S, St>
 where
     St: apply_writes_state::State,
-    St::Repo: apply_writes_state::IsSet,
     St::Writes: apply_writes_state::IsSet,
+    St::Repo: apply_writes_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ApplyWrites<S> {
@@ -1378,49 +1378,49 @@ pub mod update_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Value;
         type Rkey;
+        type Value;
         type Collection;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Value = Unset;
         type Rkey = Unset;
+        type Value = Unset;
         type Collection = Unset;
     }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
-        type Value = Set<members::value>;
-        type Rkey = St::Rkey;
-        type Collection = St::Collection;
-    }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Value = St::Value;
         type Rkey = Set<members::rkey>;
+        type Value = St::Value;
+        type Collection = St::Collection;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Rkey = St::Rkey;
+        type Value = Set<members::value>;
         type Collection = St::Collection;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Value = St::Value;
         type Rkey = St::Rkey;
+        type Value = St::Value;
         type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `value` field
-        pub struct value(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `value` field
+        pub struct value(());
         ///Marker type for the `collection` field
         pub struct collection(());
     }
@@ -1511,8 +1511,8 @@ where
 impl<S: BosStr, St> UpdateBuilder<S, St>
 where
     St: update_state::State,
-    St::Value: update_state::IsSet,
     St::Rkey: update_state::IsSet,
+    St::Value: update_state::IsSet,
     St::Collection: update_state::IsSet,
 {
     /// Build the final struct.
@@ -1545,37 +1545,37 @@ pub mod update_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Cid;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
+        type Uri = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
         type Cid = Set<members::cid>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -1664,8 +1664,8 @@ impl<S: BosStr, St: update_result_state::State> UpdateResultBuilder<S, St> {
 impl<S: BosStr, St> UpdateResultBuilder<S, St>
 where
     St: update_result_state::State,
-    St::Uri: update_result_state::IsSet,
     St::Cid: update_result_state::IsSet,
+    St::Uri: update_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateResult<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/create_record.rs b/crates/jacquard-api/src/com_atproto/repo/create_record.rs
index fbfbef51..8c100643 100644
--- a/crates/jacquard-api/src/com_atproto/repo/create_record.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/create_record.rs
@@ -222,50 +222,50 @@ pub mod create_record_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Record;
-        type Collection;
         type Repo;
+        type Collection;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Record = Unset;
-        type Collection = Unset;
         type Repo = Unset;
+        type Collection = Unset;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
         type Record = Set<members::record>;
-        type Collection = St::Collection;
-        type Repo = St::Repo;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Record = St::Record;
-        type Collection = Set<members::collection>;
         type Repo = St::Repo;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
         type Record = St::Record;
-        type Collection = St::Collection;
         type Repo = Set<members::repo>;
+        type Collection = St::Collection;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Record = St::Record;
+        type Repo = St::Repo;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `record` field
         pub struct record(());
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
     }
 }
 
@@ -401,8 +401,8 @@ impl<S: BosStr, St> CreateRecordBuilder<S, St>
 where
     St: create_record_state::State,
     St::Record: create_record_state::IsSet,
-    St::Collection: create_record_state::IsSet,
     St::Repo: create_record_state::IsSet,
+    St::Collection: create_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CreateRecord<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/delete_record.rs b/crates/jacquard-api/src/com_atproto/repo/delete_record.rs
index 21940442..fa9f4e7c 100644
--- a/crates/jacquard-api/src/com_atproto/repo/delete_record.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/delete_record.rs
@@ -129,50 +129,50 @@ pub mod delete_record_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Rkey;
-        type Collection;
         type Repo;
+        type Collection;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Rkey = Unset;
-        type Collection = Unset;
         type Repo = Unset;
+        type Collection = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
         type Rkey = Set<members::rkey>;
-        type Collection = St::Collection;
-        type Repo = St::Repo;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Rkey = St::Rkey;
-        type Collection = Set<members::collection>;
         type Repo = St::Repo;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
         type Rkey = St::Rkey;
-        type Collection = St::Collection;
         type Repo = Set<members::repo>;
+        type Collection = St::Collection;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Rkey = St::Rkey;
+        type Repo = St::Repo;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `rkey` field
         pub struct rkey(());
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
     }
 }
 
@@ -294,8 +294,8 @@ impl<S: BosStr, St> DeleteRecordBuilder<S, St>
 where
     St: delete_record_state::State,
     St::Rkey: delete_record_state::IsSet,
-    St::Collection: delete_record_state::IsSet,
     St::Repo: delete_record_state::IsSet,
+    St::Collection: delete_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeleteRecord<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/get_record.rs b/crates/jacquard-api/src/com_atproto/repo/get_record.rs
index a8a2a835..9b1ecd72 100644
--- a/crates/jacquard-api/src/com_atproto/repo/get_record.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/get_record.rs
@@ -116,51 +116,51 @@ pub mod get_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Collection;
         type Rkey;
         type Repo;
+        type Collection;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Collection = Unset;
         type Rkey = Unset;
         type Repo = Unset;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
-        type Rkey = St::Rkey;
-        type Repo = St::Repo;
+        type Collection = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Collection = St::Collection;
         type Rkey = Set<members::rkey>;
         type Repo = St::Repo;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Collection = St::Collection;
         type Rkey = St::Rkey;
         type Repo = Set<members::repo>;
+        type Collection = St::Collection;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Rkey = St::Rkey;
+        type Repo = St::Repo;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
     }
 }
 
@@ -267,9 +267,9 @@ where
 impl<S: BosStr, St> GetRecordBuilder<S, St>
 where
     St: get_record_state::State,
-    St::Collection: get_record_state::IsSet,
     St::Rkey: get_record_state::IsSet,
     St::Repo: get_record_state::IsSet,
+    St::Collection: get_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetRecord<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/import_repo.rs b/crates/jacquard-api/src/com_atproto/repo/import_repo.rs
index a5ed2732..3a33f3a6 100644
--- a/crates/jacquard-api/src/com_atproto/repo/import_repo.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/import_repo.rs
@@ -40,7 +40,7 @@ impl jacquard_common::xrpc::XrpcRequest for ImportRepo {
     type Response = ImportRepoResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/com_atproto/repo/list_records.rs b/crates/jacquard-api/src/com_atproto/repo/list_records.rs
index d79e0221..26732584 100644
--- a/crates/jacquard-api/src/com_atproto/repo/list_records.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/list_records.rs
@@ -117,37 +117,37 @@ pub mod list_records_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Collection;
         type Repo;
+        type Collection;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Collection = Unset;
         type Repo = Unset;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
-        type Repo = St::Repo;
+        type Collection = Unset;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Collection = St::Collection;
         type Repo = Set<members::repo>;
+        type Collection = St::Collection;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Repo = St::Repo;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
     }
 }
 
@@ -262,8 +262,8 @@ impl<S: BosStr, St: list_records_state::State> ListRecordsBuilder<S, St> {
 impl<S: BosStr, St> ListRecordsBuilder<S, St>
 where
     St: list_records_state::State,
-    St::Collection: list_records_state::IsSet,
     St::Repo: list_records_state::IsSet,
+    St::Collection: list_records_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListRecords<S> {
@@ -287,51 +287,51 @@ pub mod record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Value;
-        type Cid;
         type Uri;
+        type Cid;
+        type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Value = Unset;
-        type Cid = Unset;
         type Uri = Unset;
+        type Cid = Unset;
+        type Value = Unset;
     }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
-        type Value = Set<members::value>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
-        type Uri = St::Uri;
+        type Value = St::Value;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Value = St::Value;
-        type Cid = Set<members::cid>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Cid = Set<members::cid>;
         type Value = St::Value;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Uri = St::Uri;
         type Cid = St::Cid;
-        type Uri = Set<members::uri>;
+        type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `value` field
-        pub struct value(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `value` field
+        pub struct value(());
     }
 }
 
@@ -420,9 +420,9 @@ where
 impl<S: BosStr, St> RecordBuilder<S, St>
 where
     St: record_state::State,
-    St::Value: record_state::IsSet,
-    St::Cid: record_state::IsSet,
     St::Uri: record_state::IsSet,
+    St::Cid: record_state::IsSet,
+    St::Value: record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Record<S> {
diff --git a/crates/jacquard-api/src/com_atproto/repo/put_record.rs b/crates/jacquard-api/src/com_atproto/repo/put_record.rs
index 4a1ebe1f..5e7e6597 100644
--- a/crates/jacquard-api/src/com_atproto/repo/put_record.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/put_record.rs
@@ -222,65 +222,65 @@ pub mod put_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Collection;
         type Record;
+        type Repo;
         type Rkey;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Collection = Unset;
         type Record = Unset;
+        type Repo = Unset;
         type Rkey = Unset;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Collection = St::Collection;
-        type Record = St::Record;
-        type Rkey = St::Rkey;
-    }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Repo = St::Repo;
         type Collection = Set<members::collection>;
         type Record = St::Record;
+        type Repo = St::Repo;
         type Rkey = St::Rkey;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Repo = St::Repo;
         type Collection = St::Collection;
         type Record = Set<members::record>;
+        type Repo = St::Repo;
+        type Rkey = St::Rkey;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Collection = St::Collection;
+        type Record = St::Record;
+        type Repo = Set<members::repo>;
         type Rkey = St::Rkey;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Repo = St::Repo;
         type Collection = St::Collection;
         type Record = St::Record;
+        type Repo = St::Repo;
         type Rkey = Set<members::rkey>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `collection` field
         pub struct collection(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
     }
@@ -437,9 +437,9 @@ impl<S: BosStr, St: put_record_state::State> PutRecordBuilder<S, St> {
 impl<S: BosStr, St> PutRecordBuilder<S, St>
 where
     St: put_record_state::State,
-    St::Repo: put_record_state::IsSet,
     St::Collection: put_record_state::IsSet,
     St::Record: put_record_state::IsSet,
+    St::Repo: put_record_state::IsSet,
     St::Rkey: put_record_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/com_atproto/repo/upload_blob.rs b/crates/jacquard-api/src/com_atproto/repo/upload_blob.rs
index 759037d4..3afcf441 100644
--- a/crates/jacquard-api/src/com_atproto/repo/upload_blob.rs
+++ b/crates/jacquard-api/src/com_atproto/repo/upload_blob.rs
@@ -50,7 +50,7 @@ impl jacquard_common::xrpc::XrpcRequest for UploadBlob {
     type Response = UploadBlobResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/com_atproto/server.rs b/crates/jacquard-api/src/com_atproto/server.rs
index b810dc69..ab36f756 100644
--- a/crates/jacquard-api/src/com_atproto/server.rs
+++ b/crates/jacquard-api/src/com_atproto/server.rs
@@ -118,126 +118,126 @@ pub mod invite_code_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type CreatedBy;
+        type ForAccount;
         type Uses;
-        type Disabled;
-        type Available;
         type Code;
-        type ForAccount;
+        type Available;
+        type Disabled;
+        type CreatedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type CreatedBy = Unset;
+        type ForAccount = Unset;
         type Uses = Unset;
-        type Disabled = Unset;
-        type Available = Unset;
         type Code = Unset;
-        type ForAccount = Unset;
+        type Available = Unset;
+        type Disabled = Unset;
+        type CreatedBy = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = St::Uses;
-        type Disabled = St::Disabled;
-        type Available = St::Available;
         type Code = St::Code;
-        type ForAccount = St::ForAccount;
+        type Available = St::Available;
+        type Disabled = St::Disabled;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `created_by` field to Set
-    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
-    impl<St: State> State for SetCreatedBy<St> {
+    ///State transition - sets the `for_account` field to Set
+    pub struct SetForAccount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetForAccount<St> {}
+    impl<St: State> State for SetForAccount<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = Set<members::created_by>;
+        type ForAccount = Set<members::for_account>;
         type Uses = St::Uses;
-        type Disabled = St::Disabled;
-        type Available = St::Available;
         type Code = St::Code;
-        type ForAccount = St::ForAccount;
+        type Available = St::Available;
+        type Disabled = St::Disabled;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `uses` field to Set
     pub struct SetUses<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUses<St> {}
     impl<St: State> State for SetUses<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = Set<members::uses>;
-        type Disabled = St::Disabled;
-        type Available = St::Available;
         type Code = St::Code;
-        type ForAccount = St::ForAccount;
+        type Available = St::Available;
+        type Disabled = St::Disabled;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `disabled` field to Set
-    pub struct SetDisabled<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisabled<St> {}
-    impl<St: State> State for SetDisabled<St> {
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = St::Uses;
-        type Disabled = Set<members::disabled>;
+        type Code = Set<members::code>;
         type Available = St::Available;
-        type Code = St::Code;
-        type ForAccount = St::ForAccount;
+        type Disabled = St::Disabled;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `available` field to Set
     pub struct SetAvailable<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAvailable<St> {}
     impl<St: State> State for SetAvailable<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = St::Uses;
-        type Disabled = St::Disabled;
-        type Available = Set<members::available>;
         type Code = St::Code;
-        type ForAccount = St::ForAccount;
+        type Available = Set<members::available>;
+        type Disabled = St::Disabled;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
+    ///State transition - sets the `disabled` field to Set
+    pub struct SetDisabled<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisabled<St> {}
+    impl<St: State> State for SetDisabled<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = St::Uses;
-        type Disabled = St::Disabled;
+        type Code = St::Code;
         type Available = St::Available;
-        type Code = Set<members::code>;
-        type ForAccount = St::ForAccount;
+        type Disabled = Set<members::disabled>;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `for_account` field to Set
-    pub struct SetForAccount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetForAccount<St> {}
-    impl<St: State> State for SetForAccount<St> {
+    ///State transition - sets the `created_by` field to Set
+    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
+    impl<St: State> State for SetCreatedBy<St> {
         type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
+        type ForAccount = St::ForAccount;
         type Uses = St::Uses;
-        type Disabled = St::Disabled;
-        type Available = St::Available;
         type Code = St::Code;
-        type ForAccount = Set<members::for_account>;
+        type Available = St::Available;
+        type Disabled = St::Disabled;
+        type CreatedBy = Set<members::created_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `created_by` field
-        pub struct created_by(());
+        ///Marker type for the `for_account` field
+        pub struct for_account(());
         ///Marker type for the `uses` field
         pub struct uses(());
-        ///Marker type for the `disabled` field
-        pub struct disabled(());
-        ///Marker type for the `available` field
-        pub struct available(());
         ///Marker type for the `code` field
         pub struct code(());
-        ///Marker type for the `for_account` field
-        pub struct for_account(());
+        ///Marker type for the `available` field
+        pub struct available(());
+        ///Marker type for the `disabled` field
+        pub struct disabled(());
+        ///Marker type for the `created_by` field
+        pub struct created_by(());
     }
 }
 
@@ -411,12 +411,12 @@ impl<S: BosStr, St> InviteCodeBuilder<S, St>
 where
     St: invite_code_state::State,
     St::CreatedAt: invite_code_state::IsSet,
-    St::CreatedBy: invite_code_state::IsSet,
+    St::ForAccount: invite_code_state::IsSet,
     St::Uses: invite_code_state::IsSet,
-    St::Disabled: invite_code_state::IsSet,
-    St::Available: invite_code_state::IsSet,
     St::Code: invite_code_state::IsSet,
-    St::ForAccount: invite_code_state::IsSet,
+    St::Available: invite_code_state::IsSet,
+    St::Disabled: invite_code_state::IsSet,
+    St::CreatedBy: invite_code_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> InviteCode<S> {
diff --git a/crates/jacquard-api/src/com_atproto/server/create_app_password.rs b/crates/jacquard-api/src/com_atproto/server/create_app_password.rs
index 1f399fda..7a1d57aa 100644
--- a/crates/jacquard-api/src/com_atproto/server/create_app_password.rs
+++ b/crates/jacquard-api/src/com_atproto/server/create_app_password.rs
@@ -157,50 +157,50 @@ pub mod app_password_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Name;
         type Password;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Name = Unset;
         type Password = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
-        type Password = St::Password;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
-        type Name = Set<members::name>;
         type Password = St::Password;
+        type Name = St::Name;
     }
     ///State transition - sets the `password` field to Set
     pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPassword<St> {}
     impl<St: State> State for SetPassword<St> {
         type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
         type Password = Set<members::password>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Password = St::Password;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `password` field
         pub struct password(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -303,8 +303,8 @@ impl<S: BosStr, St> AppPasswordBuilder<S, St>
 where
     St: app_password_state::State,
     St::CreatedAt: app_password_state::IsSet,
-    St::Name: app_password_state::IsSet,
     St::Password: app_password_state::IsSet,
+    St::Name: app_password_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AppPassword<S> {
diff --git a/crates/jacquard-api/src/com_atproto/server/delete_account.rs b/crates/jacquard-api/src/com_atproto/server/delete_account.rs
index e5b61917..39d5141c 100644
--- a/crates/jacquard-api/src/com_atproto/server/delete_account.rs
+++ b/crates/jacquard-api/src/com_atproto/server/delete_account.rs
@@ -116,51 +116,51 @@ pub mod delete_account_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Password;
         type Did;
         type Token;
-        type Password;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Password = Unset;
         type Did = Unset;
         type Token = Unset;
-        type Password = Unset;
+    }
+    ///State transition - sets the `password` field to Set
+    pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPassword<St> {}
+    impl<St: State> State for SetPassword<St> {
+        type Password = Set<members::password>;
+        type Did = St::Did;
+        type Token = St::Token;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
+        type Password = St::Password;
         type Did = Set<members::did>;
         type Token = St::Token;
-        type Password = St::Password;
     }
     ///State transition - sets the `token` field to Set
     pub struct SetToken<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetToken<St> {}
     impl<St: State> State for SetToken<St> {
-        type Did = St::Did;
-        type Token = Set<members::token>;
         type Password = St::Password;
-    }
-    ///State transition - sets the `password` field to Set
-    pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPassword<St> {}
-    impl<St: State> State for SetPassword<St> {
         type Did = St::Did;
-        type Token = St::Token;
-        type Password = Set<members::password>;
+        type Token = Set<members::token>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `password` field
+        pub struct password(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `token` field
         pub struct token(());
-        ///Marker type for the `password` field
-        pub struct password(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> DeleteAccountBuilder<S, St>
 where
     St: delete_account_state::State,
+    St::Password: delete_account_state::IsSet,
     St::Did: delete_account_state::IsSet,
     St::Token: delete_account_state::IsSet,
-    St::Password: delete_account_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeleteAccount<S> {
diff --git a/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs b/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs
index 8e4e0ab6..ca3ab5c3 100644
--- a/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs
+++ b/crates/jacquard-api/src/com_atproto/server/list_app_passwords.rs
@@ -141,37 +141,37 @@ pub mod app_password_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -254,8 +254,8 @@ impl<S: BosStr, St: app_password_state::State> AppPasswordBuilder<S, St> {
 impl<S: BosStr, St> AppPasswordBuilder<S, St>
 where
     St: app_password_state::State,
-    St::CreatedAt: app_password_state::IsSet,
     St::Name: app_password_state::IsSet,
+    St::CreatedAt: app_password_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AppPassword<S> {
diff --git a/crates/jacquard-api/src/com_atproto/sync/get_record.rs b/crates/jacquard-api/src/com_atproto/sync/get_record.rs
index 9d3325f9..23582c61 100644
--- a/crates/jacquard-api/src/com_atproto/sync/get_record.rs
+++ b/crates/jacquard-api/src/com_atproto/sync/get_record.rs
@@ -164,51 +164,51 @@ pub mod get_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
-        type Collection;
         type Rkey;
+        type Collection;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
-        type Collection = Unset;
         type Rkey = Unset;
+        type Collection = Unset;
+        type Did = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
+    ///State transition - sets the `rkey` field to Set
+    pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRkey<St> {}
+    impl<St: State> State for SetRkey<St> {
+        type Rkey = Set<members::rkey>;
         type Collection = St::Collection;
-        type Rkey = St::Rkey;
+        type Did = St::Did;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Did = St::Did;
-        type Collection = Set<members::collection>;
         type Rkey = St::Rkey;
-    }
-    ///State transition - sets the `rkey` field to Set
-    pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRkey<St> {}
-    impl<St: State> State for SetRkey<St> {
+        type Collection = Set<members::collection>;
         type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Rkey = St::Rkey;
         type Collection = St::Collection;
-        type Rkey = Set<members::rkey>;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -297,9 +297,9 @@ where
 impl<S: BosStr, St> GetRecordBuilder<S, St>
 where
     St: get_record_state::State,
-    St::Did: get_record_state::IsSet,
-    St::Collection: get_record_state::IsSet,
     St::Rkey: get_record_state::IsSet,
+    St::Collection: get_record_state::IsSet,
+    St::Did: get_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetRecord<S> {
diff --git a/crates/jacquard-api/src/com_atproto/sync/list_repos.rs b/crates/jacquard-api/src/com_atproto/sync/list_repos.rs
index 25b861e4..30f45ee4 100644
--- a/crates/jacquard-api/src/com_atproto/sync/list_repos.rs
+++ b/crates/jacquard-api/src/com_atproto/sync/list_repos.rs
@@ -296,51 +296,51 @@ pub mod repo_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Head;
         type Rev;
         type Did;
+        type Head;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Head = Unset;
         type Rev = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `head` field to Set
-    pub struct SetHead<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHead<St> {}
-    impl<St: State> State for SetHead<St> {
-        type Head = Set<members::head>;
-        type Rev = St::Rev;
-        type Did = St::Did;
+        type Head = Unset;
     }
     ///State transition - sets the `rev` field to Set
     pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRev<St> {}
     impl<St: State> State for SetRev<St> {
-        type Head = St::Head;
         type Rev = Set<members::rev>;
         type Did = St::Did;
+        type Head = St::Head;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Head = St::Head;
         type Rev = St::Rev;
         type Did = Set<members::did>;
+        type Head = St::Head;
+    }
+    ///State transition - sets the `head` field to Set
+    pub struct SetHead<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHead<St> {}
+    impl<St: State> State for SetHead<St> {
+        type Rev = St::Rev;
+        type Did = St::Did;
+        type Head = Set<members::head>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `head` field
-        pub struct head(());
         ///Marker type for the `rev` field
         pub struct rev(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `head` field
+        pub struct head(());
     }
 }
 
@@ -461,9 +461,9 @@ impl<S: BosStr, St: repo_state::State> RepoBuilder<S, St> {
 impl<S: BosStr, St> RepoBuilder<S, St>
 where
     St: repo_state::State,
-    St::Head: repo_state::IsSet,
     St::Rev: repo_state::IsSet,
     St::Did: repo_state::IsSet,
+    St::Head: repo_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Repo<S> {
diff --git a/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs b/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs
index 9ecd51b1..4cb32941 100644
--- a/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs
+++ b/crates/jacquard-api/src/com_atproto/sync/subscribe_repos.rs
@@ -664,67 +664,67 @@ pub mod account_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Seq;
         type Did;
-        type Time;
         type Active;
-        type Seq;
+        type Time;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Seq = Unset;
         type Did = Unset;
-        type Time = Unset;
         type Active = Unset;
-        type Seq = Unset;
+        type Time = Unset;
+    }
+    ///State transition - sets the `seq` field to Set
+    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSeq<St> {}
+    impl<St: State> State for SetSeq<St> {
+        type Seq = Set<members::seq>;
+        type Did = St::Did;
+        type Active = St::Active;
+        type Time = St::Time;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Time = St::Time;
-        type Active = St::Active;
         type Seq = St::Seq;
-    }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
-        type Did = St::Did;
-        type Time = Set<members::time>;
+        type Did = Set<members::did>;
         type Active = St::Active;
-        type Seq = St::Seq;
+        type Time = St::Time;
     }
     ///State transition - sets the `active` field to Set
     pub struct SetActive<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActive<St> {}
     impl<St: State> State for SetActive<St> {
+        type Seq = St::Seq;
         type Did = St::Did;
-        type Time = St::Time;
         type Active = Set<members::active>;
-        type Seq = St::Seq;
+        type Time = St::Time;
     }
-    ///State transition - sets the `seq` field to Set
-    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSeq<St> {}
-    impl<St: State> State for SetSeq<St> {
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
+        type Seq = St::Seq;
         type Did = St::Did;
-        type Time = St::Time;
         type Active = St::Active;
-        type Seq = Set<members::seq>;
+        type Time = Set<members::time>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `seq` field
+        pub struct seq(());
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `time` field
-        pub struct time(());
         ///Marker type for the `active` field
         pub struct active(());
-        ///Marker type for the `seq` field
-        pub struct seq(());
+        ///Marker type for the `time` field
+        pub struct time(());
     }
 }
 
@@ -851,10 +851,10 @@ where
 impl<S: BosStr, St> AccountBuilder<S, St>
 where
     St: account_state::State,
+    St::Seq: account_state::IsSet,
     St::Did: account_state::IsSet,
-    St::Time: account_state::IsSet,
     St::Active: account_state::IsSet,
-    St::Seq: account_state::IsSet,
+    St::Time: account_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Account<S> {
@@ -1305,205 +1305,205 @@ pub mod commit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Time;
+        type Rev;
         type Seq;
         type TooBig;
+        type Commit;
         type Ops;
-        type Rev;
-        type Rebase;
-        type Repo;
         type Blocks;
+        type Repo;
         type Blobs;
-        type Commit;
+        type Time;
+        type Rebase;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Time = Unset;
+        type Rev = Unset;
         type Seq = Unset;
         type TooBig = Unset;
+        type Commit = Unset;
         type Ops = Unset;
-        type Rev = Unset;
-        type Rebase = Unset;
-        type Repo = Unset;
         type Blocks = Unset;
+        type Repo = Unset;
         type Blobs = Unset;
-        type Commit = Unset;
+        type Time = Unset;
+        type Rebase = Unset;
     }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
-        type Time = Set<members::time>;
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Rev = Set<members::rev>;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
-        type Repo = St::Repo;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
+        type Time = St::Time;
+        type Rebase = St::Rebase;
     }
     ///State transition - sets the `seq` field to Set
     pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeq<St> {}
     impl<St: State> State for SetSeq<St> {
-        type Time = St::Time;
+        type Rev = St::Rev;
         type Seq = Set<members::seq>;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
-        type Repo = St::Repo;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
+        type Time = St::Time;
+        type Rebase = St::Rebase;
     }
     ///State transition - sets the `too_big` field to Set
     pub struct SetTooBig<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTooBig<St> {}
     impl<St: State> State for SetTooBig<St> {
-        type Time = St::Time;
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = Set<members::too_big>;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
+        type Blocks = St::Blocks;
         type Repo = St::Repo;
+        type Blobs = St::Blobs;
+        type Time = St::Time;
+        type Rebase = St::Rebase;
+    }
+    ///State transition - sets the `commit` field to Set
+    pub struct SetCommit<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCommit<St> {}
+    impl<St: State> State for SetCommit<St> {
+        type Rev = St::Rev;
+        type Seq = St::Seq;
+        type TooBig = St::TooBig;
+        type Commit = Set<members::commit>;
+        type Ops = St::Ops;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
+        type Time = St::Time;
+        type Rebase = St::Rebase;
     }
     ///State transition - sets the `ops` field to Set
     pub struct SetOps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOps<St> {}
     impl<St: State> State for SetOps<St> {
-        type Time = St::Time;
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = Set<members::ops>;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
-        type Repo = St::Repo;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
-    }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
         type Time = St::Time;
-        type Seq = St::Seq;
-        type TooBig = St::TooBig;
-        type Ops = St::Ops;
-        type Rev = Set<members::rev>;
         type Rebase = St::Rebase;
-        type Repo = St::Repo;
-        type Blocks = St::Blocks;
-        type Blobs = St::Blobs;
-        type Commit = St::Commit;
     }
-    ///State transition - sets the `rebase` field to Set
-    pub struct SetRebase<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRebase<St> {}
-    impl<St: State> State for SetRebase<St> {
-        type Time = St::Time;
+    ///State transition - sets the `blocks` field to Set
+    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlocks<St> {}
+    impl<St: State> State for SetBlocks<St> {
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = Set<members::rebase>;
+        type Blocks = Set<members::blocks>;
         type Repo = St::Repo;
-        type Blocks = St::Blocks;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
+        type Time = St::Time;
+        type Rebase = St::Rebase;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Time = St::Time;
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
-        type Repo = Set<members::repo>;
         type Blocks = St::Blocks;
+        type Repo = Set<members::repo>;
         type Blobs = St::Blobs;
-        type Commit = St::Commit;
-    }
-    ///State transition - sets the `blocks` field to Set
-    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlocks<St> {}
-    impl<St: State> State for SetBlocks<St> {
         type Time = St::Time;
-        type Seq = St::Seq;
-        type TooBig = St::TooBig;
-        type Ops = St::Ops;
-        type Rev = St::Rev;
         type Rebase = St::Rebase;
-        type Repo = St::Repo;
-        type Blocks = Set<members::blocks>;
-        type Blobs = St::Blobs;
-        type Commit = St::Commit;
     }
     ///State transition - sets the `blobs` field to Set
     pub struct SetBlobs<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlobs<St> {}
     impl<St: State> State for SetBlobs<St> {
-        type Time = St::Time;
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
-        type Repo = St::Repo;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = Set<members::blobs>;
-        type Commit = St::Commit;
-    }
-    ///State transition - sets the `commit` field to Set
-    pub struct SetCommit<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCommit<St> {}
-    impl<St: State> State for SetCommit<St> {
         type Time = St::Time;
+        type Rebase = St::Rebase;
+    }
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
+        type Rev = St::Rev;
         type Seq = St::Seq;
         type TooBig = St::TooBig;
+        type Commit = St::Commit;
         type Ops = St::Ops;
-        type Rev = St::Rev;
-        type Rebase = St::Rebase;
+        type Blocks = St::Blocks;
         type Repo = St::Repo;
+        type Blobs = St::Blobs;
+        type Time = Set<members::time>;
+        type Rebase = St::Rebase;
+    }
+    ///State transition - sets the `rebase` field to Set
+    pub struct SetRebase<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRebase<St> {}
+    impl<St: State> State for SetRebase<St> {
+        type Rev = St::Rev;
+        type Seq = St::Seq;
+        type TooBig = St::TooBig;
+        type Commit = St::Commit;
+        type Ops = St::Ops;
         type Blocks = St::Blocks;
+        type Repo = St::Repo;
         type Blobs = St::Blobs;
-        type Commit = Set<members::commit>;
+        type Time = St::Time;
+        type Rebase = Set<members::rebase>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `time` field
-        pub struct time(());
+        ///Marker type for the `rev` field
+        pub struct rev(());
         ///Marker type for the `seq` field
         pub struct seq(());
         ///Marker type for the `too_big` field
         pub struct too_big(());
+        ///Marker type for the `commit` field
+        pub struct commit(());
         ///Marker type for the `ops` field
         pub struct ops(());
-        ///Marker type for the `rev` field
-        pub struct rev(());
-        ///Marker type for the `rebase` field
-        pub struct rebase(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `blocks` field
         pub struct blocks(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
         ///Marker type for the `blobs` field
         pub struct blobs(());
-        ///Marker type for the `commit` field
-        pub struct commit(());
+        ///Marker type for the `time` field
+        pub struct time(());
+        ///Marker type for the `rebase` field
+        pub struct rebase(());
     }
 }
 
@@ -1777,16 +1777,16 @@ where
 impl<S: BosStr, St> CommitBuilder<S, St>
 where
     St: commit_state::State,
-    St::Time: commit_state::IsSet,
+    St::Rev: commit_state::IsSet,
     St::Seq: commit_state::IsSet,
     St::TooBig: commit_state::IsSet,
+    St::Commit: commit_state::IsSet,
     St::Ops: commit_state::IsSet,
-    St::Rev: commit_state::IsSet,
-    St::Rebase: commit_state::IsSet,
-    St::Repo: commit_state::IsSet,
     St::Blocks: commit_state::IsSet,
+    St::Repo: commit_state::IsSet,
     St::Blobs: commit_state::IsSet,
-    St::Commit: commit_state::IsSet,
+    St::Time: commit_state::IsSet,
+    St::Rebase: commit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Commit<S> {
@@ -1837,50 +1837,50 @@ pub mod identity_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Time;
-        type Did;
         type Seq;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Time = Unset;
-        type Did = Unset;
         type Seq = Unset;
+        type Did = Unset;
     }
     ///State transition - sets the `time` field to Set
     pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTime<St> {}
     impl<St: State> State for SetTime<St> {
         type Time = Set<members::time>;
-        type Did = St::Did;
-        type Seq = St::Seq;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Time = St::Time;
-        type Did = Set<members::did>;
         type Seq = St::Seq;
+        type Did = St::Did;
     }
     ///State transition - sets the `seq` field to Set
     pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeq<St> {}
     impl<St: State> State for SetSeq<St> {
         type Time = St::Time;
-        type Did = St::Did;
         type Seq = Set<members::seq>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Time = St::Time;
+        type Seq = St::Seq;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `time` field
         pub struct time(());
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `seq` field
         pub struct seq(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -1983,8 +1983,8 @@ impl<S: BosStr, St> IdentityBuilder<S, St>
 where
     St: identity_state::State,
     St::Time: identity_state::IsSet,
-    St::Did: identity_state::IsSet,
     St::Seq: identity_state::IsSet,
+    St::Did: identity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Identity<S> {
@@ -2251,85 +2251,85 @@ pub mod sync_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Blocks;
-        type Rev;
-        type Seq;
-        type Did;
         type Time;
+        type Did;
+        type Seq;
+        type Rev;
+        type Blocks;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Blocks = Unset;
-        type Rev = Unset;
-        type Seq = Unset;
-        type Did = Unset;
         type Time = Unset;
+        type Did = Unset;
+        type Seq = Unset;
+        type Rev = Unset;
+        type Blocks = Unset;
     }
-    ///State transition - sets the `blocks` field to Set
-    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlocks<St> {}
-    impl<St: State> State for SetBlocks<St> {
-        type Blocks = Set<members::blocks>;
-        type Rev = St::Rev;
-        type Seq = St::Seq;
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
+        type Time = Set<members::time>;
         type Did = St::Did;
-        type Time = St::Time;
-    }
-    ///State transition - sets the `rev` field to Set
-    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev<St> {}
-    impl<St: State> State for SetRev<St> {
-        type Blocks = St::Blocks;
-        type Rev = Set<members::rev>;
         type Seq = St::Seq;
-        type Did = St::Did;
-        type Time = St::Time;
-    }
-    ///State transition - sets the `seq` field to Set
-    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSeq<St> {}
-    impl<St: State> State for SetSeq<St> {
-        type Blocks = St::Blocks;
         type Rev = St::Rev;
-        type Seq = Set<members::seq>;
-        type Did = St::Did;
-        type Time = St::Time;
+        type Blocks = St::Blocks;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Blocks = St::Blocks;
-        type Rev = St::Rev;
-        type Seq = St::Seq;
-        type Did = Set<members::did>;
         type Time = St::Time;
-    }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
+        type Did = Set<members::did>;
+        type Seq = St::Seq;
+        type Rev = St::Rev;
         type Blocks = St::Blocks;
+    }
+    ///State transition - sets the `seq` field to Set
+    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSeq<St> {}
+    impl<St: State> State for SetSeq<St> {
+        type Time = St::Time;
+        type Did = St::Did;
+        type Seq = Set<members::seq>;
         type Rev = St::Rev;
+        type Blocks = St::Blocks;
+    }
+    ///State transition - sets the `rev` field to Set
+    pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev<St> {}
+    impl<St: State> State for SetRev<St> {
+        type Time = St::Time;
+        type Did = St::Did;
         type Seq = St::Seq;
+        type Rev = Set<members::rev>;
+        type Blocks = St::Blocks;
+    }
+    ///State transition - sets the `blocks` field to Set
+    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlocks<St> {}
+    impl<St: State> State for SetBlocks<St> {
+        type Time = St::Time;
         type Did = St::Did;
-        type Time = Set<members::time>;
+        type Seq = St::Seq;
+        type Rev = St::Rev;
+        type Blocks = Set<members::blocks>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `blocks` field
-        pub struct blocks(());
-        ///Marker type for the `rev` field
-        pub struct rev(());
-        ///Marker type for the `seq` field
-        pub struct seq(());
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `time` field
         pub struct time(());
+        ///Marker type for the `did` field
+        pub struct did(());
+        ///Marker type for the `seq` field
+        pub struct seq(());
+        ///Marker type for the `rev` field
+        pub struct rev(());
+        ///Marker type for the `blocks` field
+        pub struct blocks(());
     }
 }
 
@@ -2453,11 +2453,11 @@ where
 impl<S: BosStr, St> SyncBuilder<S, St>
 where
     St: sync_state::State,
-    St::Blocks: sync_state::IsSet,
-    St::Rev: sync_state::IsSet,
-    St::Seq: sync_state::IsSet,
-    St::Did: sync_state::IsSet,
     St::Time: sync_state::IsSet,
+    St::Did: sync_state::IsSet,
+    St::Seq: sync_state::IsSet,
+    St::Rev: sync_state::IsSet,
+    St::Blocks: sync_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Sync<S> {
diff --git a/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs b/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs
index f83c9d84..754848ab 100644
--- a/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs
+++ b/crates/jacquard-api/src/com_atproto/temp/check_handle_availability.rs
@@ -593,37 +593,37 @@ pub mod suggestion_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Method;
         type Handle;
+        type Method;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Method = Unset;
         type Handle = Unset;
-    }
-    ///State transition - sets the `method` field to Set
-    pub struct SetMethod<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMethod<St> {}
-    impl<St: State> State for SetMethod<St> {
-        type Method = Set<members::method>;
-        type Handle = St::Handle;
+        type Method = Unset;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Method = St::Method;
         type Handle = Set<members::handle>;
+        type Method = St::Method;
+    }
+    ///State transition - sets the `method` field to Set
+    pub struct SetMethod<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMethod<St> {}
+    impl<St: State> State for SetMethod<St> {
+        type Handle = St::Handle;
+        type Method = Set<members::method>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `method` field
-        pub struct method(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `method` field
+        pub struct method(());
     }
 }
 
@@ -693,8 +693,8 @@ where
 impl<S: BosStr, St> SuggestionBuilder<S, St>
 where
     St: suggestion_state::State,
-    St::Method: suggestion_state::IsSet,
     St::Handle: suggestion_state::IsSet,
+    St::Method: suggestion_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Suggestion<S> {
diff --git a/crates/jacquard-api/src/com_chrisvanderloo/project.rs b/crates/jacquard-api/src/com_chrisvanderloo/project.rs
index f2502131..5059c83c 100644
--- a/crates/jacquard-api/src/com_chrisvanderloo/project.rs
+++ b/crates/jacquard-api/src/com_chrisvanderloo/project.rs
@@ -170,67 +170,67 @@ pub mod project_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Language;
-        type Description;
         type Title;
         type Repo;
+        type Description;
+        type Language;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Language = Unset;
-        type Description = Unset;
         type Title = Unset;
         type Repo = Unset;
-    }
-    ///State transition - sets the `language` field to Set
-    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLanguage<St> {}
-    impl<St: State> State for SetLanguage<St> {
-        type Language = Set<members::language>;
-        type Description = St::Description;
-        type Title = St::Title;
-        type Repo = St::Repo;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Language = St::Language;
-        type Description = Set<members::description>;
-        type Title = St::Title;
-        type Repo = St::Repo;
+        type Description = Unset;
+        type Language = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Language = St::Language;
-        type Description = St::Description;
         type Title = Set<members::title>;
         type Repo = St::Repo;
+        type Description = St::Description;
+        type Language = St::Language;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Language = St::Language;
-        type Description = St::Description;
         type Title = St::Title;
         type Repo = Set<members::repo>;
+        type Description = St::Description;
+        type Language = St::Language;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Title = St::Title;
+        type Repo = St::Repo;
+        type Description = Set<members::description>;
+        type Language = St::Language;
+    }
+    ///State transition - sets the `language` field to Set
+    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLanguage<St> {}
+    impl<St: State> State for SetLanguage<St> {
+        type Title = St::Title;
+        type Repo = St::Repo;
+        type Description = St::Description;
+        type Language = Set<members::language>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `language` field
-        pub struct language(());
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `description` field
+        pub struct description(());
+        ///Marker type for the `language` field
+        pub struct language(());
     }
 }
 
@@ -351,10 +351,10 @@ where
 impl<S: BosStr, St> ProjectBuilder<S, St>
 where
     St: project_state::State,
-    St::Language: project_state::IsSet,
-    St::Description: project_state::IsSet,
     St::Title: project_state::IsSet,
     St::Repo: project_state::IsSet,
+    St::Description: project_state::IsSet,
+    St::Language: project_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Project<S> {
diff --git a/crates/jacquard-api/src/com_crabdance/nandi/post.rs b/crates/jacquard-api/src/com_crabdance/nandi/post.rs
index b519cebd..5effe870 100644
--- a/crates/jacquard-api/src/com_crabdance/nandi/post.rs
+++ b/crates/jacquard-api/src/com_crabdance/nandi/post.rs
@@ -194,51 +194,51 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Content;
         type CreatedAt;
         type Title;
-        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Content = Unset;
         type CreatedAt = Unset;
         type Title = Unset;
-        type Content = Unset;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Content = Set<members::content>;
+        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Content = St::Content;
         type CreatedAt = Set<members::created_at>;
         type Title = St::Title;
-        type Content = St::Content;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
         type Content = St::Content;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-        type Content = Set<members::content>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `content` field
+        pub struct content(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `content` field
-        pub struct content(());
     }
 }
 
@@ -387,9 +387,9 @@ impl<S: BosStr, St: post_state::State> PostBuilder<S, St> {
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
+    St::Content: post_state::IsSet,
     St::CreatedAt: post_state::IsSet,
     St::Title: post_state::IsSet,
-    St::Content: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/com_deckbelcher/collection/list.rs b/crates/jacquard-api/src/com_deckbelcher/collection/list.rs
index feefbc2d..885e22ec 100644
--- a/crates/jacquard-api/src/com_deckbelcher/collection/list.rs
+++ b/crates/jacquard-api/src/com_deckbelcher/collection/list.rs
@@ -217,37 +217,37 @@ pub mod card_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AddedAt;
         type Ref;
+        type AddedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AddedAt = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `added_at` field to Set
-    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
-    impl<St: State> State for SetAddedAt<St> {
-        type AddedAt = Set<members::added_at>;
-        type Ref = St::Ref;
+        type AddedAt = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type AddedAt = St::AddedAt;
         type Ref = Set<members::r#ref>;
+        type AddedAt = St::AddedAt;
+    }
+    ///State transition - sets the `added_at` field to Set
+    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
+    impl<St: State> State for SetAddedAt<St> {
+        type Ref = St::Ref;
+        type AddedAt = Set<members::added_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `added_at` field
-        pub struct added_at(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `added_at` field
+        pub struct added_at(());
     }
 }
 
@@ -317,8 +317,8 @@ where
 impl<S: BosStr, St> CardItemBuilder<S, St>
 where
     St: card_item_state::State,
-    St::AddedAt: card_item_state::IsSet,
     St::Ref: card_item_state::IsSet,
+    St::AddedAt: card_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CardItem<S> {
@@ -510,37 +510,37 @@ pub mod deck_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AddedAt;
         type Ref;
+        type AddedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AddedAt = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `added_at` field to Set
-    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
-    impl<St: State> State for SetAddedAt<St> {
-        type AddedAt = Set<members::added_at>;
-        type Ref = St::Ref;
+        type AddedAt = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type AddedAt = St::AddedAt;
         type Ref = Set<members::r#ref>;
+        type AddedAt = St::AddedAt;
+    }
+    ///State transition - sets the `added_at` field to Set
+    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
+    impl<St: State> State for SetAddedAt<St> {
+        type Ref = St::Ref;
+        type AddedAt = Set<members::added_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `added_at` field
-        pub struct added_at(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `added_at` field
+        pub struct added_at(());
     }
 }
 
@@ -610,8 +610,8 @@ where
 impl<S: BosStr, St> DeckItemBuilder<S, St>
 where
     St: deck_item_state::State,
-    St::AddedAt: deck_item_state::IsSet,
     St::Ref: deck_item_state::IsSet,
+    St::AddedAt: deck_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeckItem<S> {
@@ -641,51 +641,51 @@ pub mod list_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Name;
         type Items;
+        type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Name = Unset;
         type Items = Unset;
+        type Name = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `items` field to Set
+    pub struct SetItems<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetItems<St> {}
+    impl<St: State> State for SetItems<St> {
+        type Items = Set<members::items>;
         type Name = St::Name;
-        type Items = St::Items;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
-        type Name = Set<members::name>;
         type Items = St::Items;
-    }
-    ///State transition - sets the `items` field to Set
-    pub struct SetItems<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetItems<St> {}
-    impl<St: State> State for SetItems<St> {
+        type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Items = St::Items;
         type Name = St::Name;
-        type Items = Set<members::items>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `items` field
         pub struct items(());
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -806,9 +806,9 @@ impl<S: BosStr, St: list_state::State> ListBuilder<S, St> {
 impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
-    St::CreatedAt: list_state::IsSet,
-    St::Name: list_state::IsSet,
     St::Items: list_state::IsSet,
+    St::Name: list_state::IsSet,
+    St::CreatedAt: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/com_deckbelcher/deck/list.rs b/crates/jacquard-api/src/com_deckbelcher/deck/list.rs
index f7f380a8..d861ba35 100644
--- a/crates/jacquard-api/src/com_deckbelcher/deck/list.rs
+++ b/crates/jacquard-api/src/com_deckbelcher/deck/list.rs
@@ -531,51 +531,51 @@ pub mod card_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Quantity;
-        type Section;
         type Ref;
+        type Section;
+        type Quantity;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Quantity = Unset;
-        type Section = Unset;
         type Ref = Unset;
+        type Section = Unset;
+        type Quantity = Unset;
     }
-    ///State transition - sets the `quantity` field to Set
-    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuantity<St> {}
-    impl<St: State> State for SetQuantity<St> {
-        type Quantity = Set<members::quantity>;
+    ///State transition - sets the `ref` field to Set
+    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRef<St> {}
+    impl<St: State> State for SetRef<St> {
+        type Ref = Set<members::r#ref>;
         type Section = St::Section;
-        type Ref = St::Ref;
+        type Quantity = St::Quantity;
     }
     ///State transition - sets the `section` field to Set
     pub struct SetSection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSection<St> {}
     impl<St: State> State for SetSection<St> {
-        type Quantity = St::Quantity;
-        type Section = Set<members::section>;
         type Ref = St::Ref;
-    }
-    ///State transition - sets the `ref` field to Set
-    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRef<St> {}
-    impl<St: State> State for SetRef<St> {
+        type Section = Set<members::section>;
         type Quantity = St::Quantity;
+    }
+    ///State transition - sets the `quantity` field to Set
+    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuantity<St> {}
+    impl<St: State> State for SetQuantity<St> {
+        type Ref = St::Ref;
         type Section = St::Section;
-        type Ref = Set<members::r#ref>;
+        type Quantity = Set<members::quantity>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `quantity` field
-        pub struct quantity(());
-        ///Marker type for the `section` field
-        pub struct section(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `section` field
+        pub struct section(());
+        ///Marker type for the `quantity` field
+        pub struct quantity(());
     }
 }
 
@@ -677,9 +677,9 @@ impl<S: BosStr, St: card_state::State> CardBuilder<S, St> {
 impl<S: BosStr, St> CardBuilder<S, St>
 where
     St: card_state::State,
-    St::Quantity: card_state::IsSet,
-    St::Section: card_state::IsSet,
     St::Ref: card_state::IsSet,
+    St::Section: card_state::IsSet,
+    St::Quantity: card_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Card<S> {
@@ -954,51 +954,51 @@ pub mod list_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cards;
         type Name;
         type CreatedAt;
+        type Cards;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cards = Unset;
         type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `cards` field to Set
-    pub struct SetCards<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCards<St> {}
-    impl<St: State> State for SetCards<St> {
-        type Cards = Set<members::cards>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
+        type Cards = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Cards = St::Cards;
         type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
+        type Cards = St::Cards;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Cards = St::Cards;
         type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Cards = St::Cards;
+    }
+    ///State transition - sets the `cards` field to Set
+    pub struct SetCards<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCards<St> {}
+    impl<St: State> State for SetCards<St> {
+        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
+        type Cards = Set<members::cards>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cards` field
-        pub struct cards(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `cards` field
+        pub struct cards(());
     }
 }
 
@@ -1133,9 +1133,9 @@ impl<S: BosStr, St: list_state::State> ListBuilder<S, St> {
 impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
-    St::Cards: list_state::IsSet,
     St::Name: list_state::IsSet,
     St::CreatedAt: list_state::IsSet,
+    St::Cards: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/com_deckbelcher/richtext/facet.rs b/crates/jacquard-api/src/com_deckbelcher/richtext/facet.rs
index 180062be..90542759 100644
--- a/crates/jacquard-api/src/com_deckbelcher/richtext/facet.rs
+++ b/crates/jacquard-api/src/com_deckbelcher/richtext/facet.rs
@@ -949,37 +949,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Features;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Features = St::Features;
+        type Index = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Index = St::Index;
         type Features = Set<members::features>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Features = St::Features;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -1049,8 +1049,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Index: facet_state::IsSet,
     St::Features: facet_state::IsSet,
+    St::Index: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/com_deckbelcher/social/reply.rs b/crates/jacquard-api/src/com_deckbelcher/social/reply.rs
index 7788a927..63348cff 100644
--- a/crates/jacquard-api/src/com_deckbelcher/social/reply.rs
+++ b/crates/jacquard-api/src/com_deckbelcher/social/reply.rs
@@ -121,67 +121,67 @@ pub mod reply_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Content;
         type Parent;
         type Root;
         type CreatedAt;
-        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Content = Unset;
         type Parent = Unset;
         type Root = Unset;
         type CreatedAt = Unset;
-        type Content = Unset;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Content = Set<members::content>;
+        type Parent = St::Parent;
+        type Root = St::Root;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `parent` field to Set
     pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParent<St> {}
     impl<St: State> State for SetParent<St> {
+        type Content = St::Content;
         type Parent = Set<members::parent>;
         type Root = St::Root;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
     }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
+        type Content = St::Content;
         type Parent = St::Parent;
         type Root = Set<members::root>;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Parent = St::Parent;
-        type Root = St::Root;
-        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
         type Parent = St::Parent;
         type Root = St::Root;
-        type CreatedAt = St::CreatedAt;
-        type Content = Set<members::content>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `content` field
+        pub struct content(());
         ///Marker type for the `parent` field
         pub struct parent(());
         ///Marker type for the `root` field
         pub struct root(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `content` field
-        pub struct content(());
     }
 }
 
@@ -308,10 +308,10 @@ impl<S: BosStr, St: reply_state::State> ReplyBuilder<S, St> {
 impl<S: BosStr, St> ReplyBuilder<S, St>
 where
     St: reply_state::State,
+    St::Content: reply_state::IsSet,
     St::Parent: reply_state::IsSet,
     St::Root: reply_state::IsSet,
     St::CreatedAt: reply_state::IsSet,
-    St::Content: reply_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reply<S> {
diff --git a/crates/jacquard-api/src/com_germnetwork/declaration.rs b/crates/jacquard-api/src/com_germnetwork/declaration.rs
index 7ed14496..a6439946 100644
--- a/crates/jacquard-api/src/com_germnetwork/declaration.rs
+++ b/crates/jacquard-api/src/com_germnetwork/declaration.rs
@@ -315,37 +315,37 @@ pub mod declaration_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CurrentKey;
         type Version;
+        type CurrentKey;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CurrentKey = Unset;
         type Version = Unset;
-    }
-    ///State transition - sets the `current_key` field to Set
-    pub struct SetCurrentKey<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCurrentKey<St> {}
-    impl<St: State> State for SetCurrentKey<St> {
-        type CurrentKey = Set<members::current_key>;
-        type Version = St::Version;
+        type CurrentKey = Unset;
     }
     ///State transition - sets the `version` field to Set
     pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVersion<St> {}
     impl<St: State> State for SetVersion<St> {
-        type CurrentKey = St::CurrentKey;
         type Version = Set<members::version>;
+        type CurrentKey = St::CurrentKey;
+    }
+    ///State transition - sets the `current_key` field to Set
+    pub struct SetCurrentKey<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCurrentKey<St> {}
+    impl<St: State> State for SetCurrentKey<St> {
+        type Version = St::Version;
+        type CurrentKey = Set<members::current_key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `current_key` field
-        pub struct current_key(());
         ///Marker type for the `version` field
         pub struct version(());
+        ///Marker type for the `current_key` field
+        pub struct current_key(());
     }
 }
 
@@ -463,8 +463,8 @@ where
 impl<S: BosStr, St> DeclarationBuilder<S, St>
 where
     St: declaration_state::State,
-    St::CurrentKey: declaration_state::IsSet,
     St::Version: declaration_state::IsSet,
+    St::CurrentKey: declaration_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Declaration<S> {
@@ -630,37 +630,37 @@ pub mod message_me_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ShowButtonTo;
         type MessageMeUrl;
+        type ShowButtonTo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ShowButtonTo = Unset;
         type MessageMeUrl = Unset;
-    }
-    ///State transition - sets the `show_button_to` field to Set
-    pub struct SetShowButtonTo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetShowButtonTo<St> {}
-    impl<St: State> State for SetShowButtonTo<St> {
-        type ShowButtonTo = Set<members::show_button_to>;
-        type MessageMeUrl = St::MessageMeUrl;
+        type ShowButtonTo = Unset;
     }
     ///State transition - sets the `message_me_url` field to Set
     pub struct SetMessageMeUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessageMeUrl<St> {}
     impl<St: State> State for SetMessageMeUrl<St> {
-        type ShowButtonTo = St::ShowButtonTo;
         type MessageMeUrl = Set<members::message_me_url>;
+        type ShowButtonTo = St::ShowButtonTo;
+    }
+    ///State transition - sets the `show_button_to` field to Set
+    pub struct SetShowButtonTo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetShowButtonTo<St> {}
+    impl<St: State> State for SetShowButtonTo<St> {
+        type MessageMeUrl = St::MessageMeUrl;
+        type ShowButtonTo = Set<members::show_button_to>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `show_button_to` field
-        pub struct show_button_to(());
         ///Marker type for the `message_me_url` field
         pub struct message_me_url(());
+        ///Marker type for the `show_button_to` field
+        pub struct show_button_to(());
     }
 }
 
@@ -730,8 +730,8 @@ where
 impl<S: BosStr, St> MessageMeBuilder<S, St>
 where
     St: message_me_state::State,
-    St::ShowButtonTo: message_me_state::IsSet,
     St::MessageMeUrl: message_me_state::IsSet,
+    St::ShowButtonTo: message_me_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MessageMe<S> {
diff --git a/crates/jacquard-api/src/com_kipclip/annotation.rs b/crates/jacquard-api/src/com_kipclip/annotation.rs
index 63695eba..ead305d1 100644
--- a/crates/jacquard-api/src/com_kipclip/annotation.rs
+++ b/crates/jacquard-api/src/com_kipclip/annotation.rs
@@ -154,37 +154,37 @@ pub mod annotation_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -327,8 +327,8 @@ impl<S: BosStr, St: annotation_state::State> AnnotationBuilder<S, St> {
 impl<S: BosStr, St> AnnotationBuilder<S, St>
 where
     St: annotation_state::State,
-    St::Subject: annotation_state::IsSet,
     St::CreatedAt: annotation_state::IsSet,
+    St::Subject: annotation_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Annotation<S> {
diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs
index 097c9b56..eb849552 100644
--- a/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs
+++ b/crates/jacquard-api/src/com_shinolabs/pinksea/app_view_defs.rs
@@ -140,37 +140,37 @@ pub mod author_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Did;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Did = St::Did;
+        type Handle = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Handle = St::Handle;
         type Did = Set<members::did>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -240,8 +240,8 @@ where
 impl<S: BosStr, St> AuthorBuilder<S, St>
 where
     St: author_state::State,
-    St::Handle: author_state::IsSet,
     St::Did: author_state::IsSet,
+    St::Handle: author_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Author<S> {
@@ -445,105 +445,105 @@ pub mod hydrated_oekaki_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Image;
         type CreationTime;
         type Nsfw;
         type Cid;
-        type At;
-        type Image;
         type Author;
+        type At;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Image = Unset;
         type CreationTime = Unset;
         type Nsfw = Unset;
         type Cid = Unset;
-        type At = Unset;
-        type Image = Unset;
         type Author = Unset;
+        type At = Unset;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type Image = Set<members::image>;
+        type CreationTime = St::CreationTime;
+        type Nsfw = St::Nsfw;
+        type Cid = St::Cid;
+        type Author = St::Author;
+        type At = St::At;
     }
     ///State transition - sets the `creation_time` field to Set
     pub struct SetCreationTime<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreationTime<St> {}
     impl<St: State> State for SetCreationTime<St> {
+        type Image = St::Image;
         type CreationTime = Set<members::creation_time>;
         type Nsfw = St::Nsfw;
         type Cid = St::Cid;
-        type At = St::At;
-        type Image = St::Image;
         type Author = St::Author;
+        type At = St::At;
     }
     ///State transition - sets the `nsfw` field to Set
     pub struct SetNsfw<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNsfw<St> {}
     impl<St: State> State for SetNsfw<St> {
+        type Image = St::Image;
         type CreationTime = St::CreationTime;
         type Nsfw = Set<members::nsfw>;
         type Cid = St::Cid;
-        type At = St::At;
-        type Image = St::Image;
         type Author = St::Author;
+        type At = St::At;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type CreationTime = St::CreationTime;
-        type Nsfw = St::Nsfw;
-        type Cid = Set<members::cid>;
-        type At = St::At;
         type Image = St::Image;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `at` field to Set
-    pub struct SetAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAt<St> {}
-    impl<St: State> State for SetAt<St> {
         type CreationTime = St::CreationTime;
         type Nsfw = St::Nsfw;
-        type Cid = St::Cid;
-        type At = Set<members::at>;
-        type Image = St::Image;
+        type Cid = Set<members::cid>;
         type Author = St::Author;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type CreationTime = St::CreationTime;
-        type Nsfw = St::Nsfw;
-        type Cid = St::Cid;
         type At = St::At;
-        type Image = Set<members::image>;
-        type Author = St::Author;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
+        type Image = St::Image;
         type CreationTime = St::CreationTime;
         type Nsfw = St::Nsfw;
         type Cid = St::Cid;
+        type Author = Set<members::author>;
         type At = St::At;
+    }
+    ///State transition - sets the `at` field to Set
+    pub struct SetAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAt<St> {}
+    impl<St: State> State for SetAt<St> {
         type Image = St::Image;
-        type Author = Set<members::author>;
+        type CreationTime = St::CreationTime;
+        type Nsfw = St::Nsfw;
+        type Cid = St::Cid;
+        type Author = St::Author;
+        type At = Set<members::at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `image` field
+        pub struct image(());
         ///Marker type for the `creation_time` field
         pub struct creation_time(());
         ///Marker type for the `nsfw` field
         pub struct nsfw(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `at` field
-        pub struct at(());
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `author` field
         pub struct author(());
+        ///Marker type for the `at` field
+        pub struct at(());
     }
 }
 
@@ -724,12 +724,12 @@ impl<S: BosStr, St: hydrated_oekaki_state::State> HydratedOekakiBuilder<S, St> {
 impl<S: BosStr, St> HydratedOekakiBuilder<S, St>
 where
     St: hydrated_oekaki_state::State,
+    St::Image: hydrated_oekaki_state::IsSet,
     St::CreationTime: hydrated_oekaki_state::IsSet,
     St::Nsfw: hydrated_oekaki_state::IsSet,
     St::Cid: hydrated_oekaki_state::IsSet,
-    St::At: hydrated_oekaki_state::IsSet,
-    St::Image: hydrated_oekaki_state::IsSet,
     St::Author: hydrated_oekaki_state::IsSet,
+    St::At: hydrated_oekaki_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> HydratedOekaki<S> {
diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/get_oekaki.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/get_oekaki.rs
index 823923a2..f791deff 100644
--- a/crates/jacquard-api/src/com_shinolabs/pinksea/get_oekaki.rs
+++ b/crates/jacquard-api/src/com_shinolabs/pinksea/get_oekaki.rs
@@ -81,37 +81,37 @@ pub mod get_oekaki_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Rkey;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Rkey = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Rkey = St::Rkey;
+        type Did = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Did = St::Did;
         type Rkey = Set<members::rkey>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Rkey = St::Rkey;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -181,8 +181,8 @@ where
 impl<S: BosStr, St> GetOekakiBuilder<S, St>
 where
     St: get_oekaki_state::State,
-    St::Did: get_oekaki_state::IsSet,
     St::Rkey: get_oekaki_state::IsSet,
+    St::Did: get_oekaki_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetOekaki<S> {
diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/get_parent_for_reply.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/get_parent_for_reply.rs
index 19aae72f..b6d0b7c1 100644
--- a/crates/jacquard-api/src/com_shinolabs/pinksea/get_parent_for_reply.rs
+++ b/crates/jacquard-api/src/com_shinolabs/pinksea/get_parent_for_reply.rs
@@ -70,37 +70,37 @@ pub mod get_parent_for_reply_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Rkey;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Rkey = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Rkey = St::Rkey;
+        type Did = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Did = St::Did;
         type Rkey = Set<members::rkey>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Rkey = St::Rkey;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -170,8 +170,8 @@ where
 impl<S: BosStr, St> GetParentForReplyBuilder<S, St>
 where
     St: get_parent_for_reply_state::State,
-    St::Did: get_parent_for_reply_state::IsSet,
     St::Rkey: get_parent_for_reply_state::IsSet,
+    St::Did: get_parent_for_reply_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetParentForReply<S> {
diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs
index 49130720..d4b401c6 100644
--- a/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs
+++ b/crates/jacquard-api/src/com_shinolabs/pinksea/oekaki.rs
@@ -228,37 +228,37 @@ pub mod image_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ImageLink;
         type Blob;
+        type ImageLink;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ImageLink = Unset;
         type Blob = Unset;
-    }
-    ///State transition - sets the `image_link` field to Set
-    pub struct SetImageLink<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImageLink<St> {}
-    impl<St: State> State for SetImageLink<St> {
-        type ImageLink = Set<members::image_link>;
-        type Blob = St::Blob;
+        type ImageLink = Unset;
     }
     ///State transition - sets the `blob` field to Set
     pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlob<St> {}
     impl<St: State> State for SetBlob<St> {
-        type ImageLink = St::ImageLink;
         type Blob = Set<members::blob>;
+        type ImageLink = St::ImageLink;
+    }
+    ///State transition - sets the `image_link` field to Set
+    pub struct SetImageLink<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImageLink<St> {}
+    impl<St: State> State for SetImageLink<St> {
+        type Blob = St::Blob;
+        type ImageLink = Set<members::image_link>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image_link` field
-        pub struct image_link(());
         ///Marker type for the `blob` field
         pub struct blob(());
+        ///Marker type for the `image_link` field
+        pub struct image_link(());
     }
 }
 
@@ -328,8 +328,8 @@ where
 impl<S: BosStr, St> ImageBuilder<S, St>
 where
     St: image_state::State,
-    St::ImageLink: image_state::IsSet,
     St::Blob: image_state::IsSet,
+    St::ImageLink: image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Image<S> {
@@ -495,37 +495,37 @@ pub mod oekaki_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type CreatedAt;
+        type Image;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type CreatedAt = St::CreatedAt;
+        type Image = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Image = St::Image;
         type CreatedAt = Set<members::created_at>;
+        type Image = St::Image;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type CreatedAt = St::CreatedAt;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `image` field
+        pub struct image(());
     }
 }
 
@@ -640,8 +640,8 @@ impl<S: BosStr, St: oekaki_state::State> OekakiBuilder<S, St> {
 impl<S: BosStr, St> OekakiBuilder<S, St>
 where
     St: oekaki_state::State,
-    St::Image: oekaki_state::IsSet,
     St::CreatedAt: oekaki_state::IsSet,
+    St::Image: oekaki_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Oekaki<S> {
diff --git a/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs b/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs
index 104004b8..3f0e589e 100644
--- a/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs
+++ b/crates/jacquard-api/src/com_shinolabs/pinksea/profile.rs
@@ -472,37 +472,37 @@ pub mod profile_link_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Link;
         type Name;
+        type Link;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Link = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `link` field to Set
-    pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLink<St> {}
-    impl<St: State> State for SetLink<St> {
-        type Link = Set<members::link>;
-        type Name = St::Name;
+        type Link = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Link = St::Link;
         type Name = Set<members::name>;
+        type Link = St::Link;
+    }
+    ///State transition - sets the `link` field to Set
+    pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLink<St> {}
+    impl<St: State> State for SetLink<St> {
+        type Name = St::Name;
+        type Link = Set<members::link>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `link` field
-        pub struct link(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `link` field
+        pub struct link(());
     }
 }
 
@@ -572,8 +572,8 @@ where
 impl<S: BosStr, St> ProfileLinkBuilder<S, St>
 where
     St: profile_link_state::State,
-    St::Link: profile_link_state::IsSet,
     St::Name: profile_link_state::IsSet,
+    St::Link: profile_link_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileLink<S> {
diff --git a/crates/jacquard-api/src/com_suibari/atsumeat/sticker.rs b/crates/jacquard-api/src/com_suibari/atsumeat/sticker.rs
index 16deda9c..1f06ec5d 100644
--- a/crates/jacquard-api/src/com_suibari/atsumeat/sticker.rs
+++ b/crates/jacquard-api/src/com_suibari/atsumeat/sticker.rs
@@ -429,105 +429,105 @@ pub mod sticker_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type SignedPayload;
+        type Image;
         type Signature;
-        type OriginalOwner;
-        type ObtainedAt;
         type Model;
+        type ObtainedAt;
+        type OriginalOwner;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type SignedPayload = Unset;
+        type Image = Unset;
         type Signature = Unset;
-        type OriginalOwner = Unset;
-        type ObtainedAt = Unset;
         type Model = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type SignedPayload = St::SignedPayload;
-        type Signature = St::Signature;
-        type OriginalOwner = St::OriginalOwner;
-        type ObtainedAt = St::ObtainedAt;
-        type Model = St::Model;
+        type ObtainedAt = Unset;
+        type OriginalOwner = Unset;
     }
     ///State transition - sets the `signed_payload` field to Set
     pub struct SetSignedPayload<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignedPayload<St> {}
     impl<St: State> State for SetSignedPayload<St> {
-        type Image = St::Image;
         type SignedPayload = Set<members::signed_payload>;
+        type Image = St::Image;
         type Signature = St::Signature;
-        type OriginalOwner = St::OriginalOwner;
+        type Model = St::Model;
         type ObtainedAt = St::ObtainedAt;
+        type OriginalOwner = St::OriginalOwner;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type SignedPayload = St::SignedPayload;
+        type Image = Set<members::image>;
+        type Signature = St::Signature;
         type Model = St::Model;
+        type ObtainedAt = St::ObtainedAt;
+        type OriginalOwner = St::OriginalOwner;
     }
     ///State transition - sets the `signature` field to Set
     pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignature<St> {}
     impl<St: State> State for SetSignature<St> {
-        type Image = St::Image;
         type SignedPayload = St::SignedPayload;
+        type Image = St::Image;
         type Signature = Set<members::signature>;
-        type OriginalOwner = St::OriginalOwner;
-        type ObtainedAt = St::ObtainedAt;
         type Model = St::Model;
+        type ObtainedAt = St::ObtainedAt;
+        type OriginalOwner = St::OriginalOwner;
     }
-    ///State transition - sets the `original_owner` field to Set
-    pub struct SetOriginalOwner<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOriginalOwner<St> {}
-    impl<St: State> State for SetOriginalOwner<St> {
-        type Image = St::Image;
+    ///State transition - sets the `model` field to Set
+    pub struct SetModel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetModel<St> {}
+    impl<St: State> State for SetModel<St> {
         type SignedPayload = St::SignedPayload;
+        type Image = St::Image;
         type Signature = St::Signature;
-        type OriginalOwner = Set<members::original_owner>;
+        type Model = Set<members::model>;
         type ObtainedAt = St::ObtainedAt;
-        type Model = St::Model;
+        type OriginalOwner = St::OriginalOwner;
     }
     ///State transition - sets the `obtained_at` field to Set
     pub struct SetObtainedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetObtainedAt<St> {}
     impl<St: State> State for SetObtainedAt<St> {
-        type Image = St::Image;
         type SignedPayload = St::SignedPayload;
+        type Image = St::Image;
         type Signature = St::Signature;
-        type OriginalOwner = St::OriginalOwner;
-        type ObtainedAt = Set<members::obtained_at>;
         type Model = St::Model;
+        type ObtainedAt = Set<members::obtained_at>;
+        type OriginalOwner = St::OriginalOwner;
     }
-    ///State transition - sets the `model` field to Set
-    pub struct SetModel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetModel<St> {}
-    impl<St: State> State for SetModel<St> {
-        type Image = St::Image;
+    ///State transition - sets the `original_owner` field to Set
+    pub struct SetOriginalOwner<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOriginalOwner<St> {}
+    impl<St: State> State for SetOriginalOwner<St> {
         type SignedPayload = St::SignedPayload;
+        type Image = St::Image;
         type Signature = St::Signature;
-        type OriginalOwner = St::OriginalOwner;
+        type Model = St::Model;
         type ObtainedAt = St::ObtainedAt;
-        type Model = Set<members::model>;
+        type OriginalOwner = Set<members::original_owner>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `signed_payload` field
         pub struct signed_payload(());
+        ///Marker type for the `image` field
+        pub struct image(());
         ///Marker type for the `signature` field
         pub struct signature(());
-        ///Marker type for the `original_owner` field
-        pub struct original_owner(());
-        ///Marker type for the `obtained_at` field
-        pub struct obtained_at(());
         ///Marker type for the `model` field
         pub struct model(());
+        ///Marker type for the `obtained_at` field
+        pub struct obtained_at(());
+        ///Marker type for the `original_owner` field
+        pub struct original_owner(());
     }
 }
 
@@ -792,12 +792,12 @@ impl<S: BosStr, St: sticker_state::State> StickerBuilder<S, St> {
 impl<S: BosStr, St> StickerBuilder<S, St>
 where
     St: sticker_state::State,
-    St::Image: sticker_state::IsSet,
     St::SignedPayload: sticker_state::IsSet,
+    St::Image: sticker_state::IsSet,
     St::Signature: sticker_state::IsSet,
-    St::OriginalOwner: sticker_state::IsSet,
-    St::ObtainedAt: sticker_state::IsSet,
     St::Model: sticker_state::IsSet,
+    St::ObtainedAt: sticker_state::IsSet,
+    St::OriginalOwner: sticker_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Sticker<S> {
diff --git a/crates/jacquard-api/src/com_suibari/atsumeat/transaction.rs b/crates/jacquard-api/src/com_suibari/atsumeat/transaction.rs
index 200e74c4..d35b4f73 100644
--- a/crates/jacquard-api/src/com_suibari/atsumeat/transaction.rs
+++ b/crates/jacquard-api/src/com_suibari/atsumeat/transaction.rs
@@ -250,37 +250,37 @@ pub mod transaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Status;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Status = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Status = St::Status;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type CreatedAt = St::CreatedAt;
         type Status = Set<members::status>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Status = St::Status;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -451,8 +451,8 @@ impl<S: BosStr, St: transaction_state::State> TransactionBuilder<S, St> {
 impl<S: BosStr, St> TransactionBuilder<S, St>
 where
     St: transaction_state::State,
-    St::CreatedAt: transaction_state::IsSet,
     St::Status: transaction_state::IsSet,
+    St::CreatedAt: transaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Transaction<S> {
diff --git a/crates/jacquard-api/src/com_whtwnd/blog.rs b/crates/jacquard-api/src/com_whtwnd/blog.rs
index 4f1e173b..a812cbc3 100644
--- a/crates/jacquard-api/src/com_whtwnd/blog.rs
+++ b/crates/jacquard-api/src/com_whtwnd/blog.rs
@@ -435,37 +435,37 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type EntryUri;
         type Content;
+        type EntryUri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type EntryUri = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `entry_uri` field to Set
-    pub struct SetEntryUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEntryUri<St> {}
-    impl<St: State> State for SetEntryUri<St> {
-        type EntryUri = Set<members::entry_uri>;
-        type Content = St::Content;
+        type EntryUri = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type EntryUri = St::EntryUri;
         type Content = Set<members::content>;
+        type EntryUri = St::EntryUri;
+    }
+    ///State transition - sets the `entry_uri` field to Set
+    pub struct SetEntryUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEntryUri<St> {}
+    impl<St: State> State for SetEntryUri<St> {
+        type Content = St::Content;
+        type EntryUri = Set<members::entry_uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `entry_uri` field
-        pub struct entry_uri(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `entry_uri` field
+        pub struct entry_uri(());
     }
 }
 
@@ -535,8 +535,8 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::EntryUri: comment_state::IsSet,
     St::Content: comment_state::IsSet,
+    St::EntryUri: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/community_lexicon/calendar/event.rs b/crates/jacquard-api/src/community_lexicon/calendar/event.rs
index e2fc3abf..9f861abe 100644
--- a/crates/jacquard-api/src/community_lexicon/calendar/event.rs
+++ b/crates/jacquard-api/src/community_lexicon/calendar/event.rs
@@ -475,37 +475,37 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -679,8 +679,8 @@ impl<S: BosStr, St: event_state::State> EventBuilder<S, St> {
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::Name: event_state::IsSet,
     St::CreatedAt: event_state::IsSet,
+    St::Name: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/community_lexicon/calendar/get_event.rs b/crates/jacquard-api/src/community_lexicon/calendar/get_event.rs
index 93d86683..38785701 100644
--- a/crates/jacquard-api/src/community_lexicon/calendar/get_event.rs
+++ b/crates/jacquard-api/src/community_lexicon/calendar/get_event.rs
@@ -151,67 +151,67 @@ pub mod event_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CountNotGoing;
-        type CountInterested;
         type Url;
+        type CountInterested;
         type CountGoing;
+        type CountNotGoing;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CountNotGoing = Unset;
-        type CountInterested = Unset;
         type Url = Unset;
+        type CountInterested = Unset;
         type CountGoing = Unset;
+        type CountNotGoing = Unset;
     }
-    ///State transition - sets the `count_not_going` field to Set
-    pub struct SetCountNotGoing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCountNotGoing<St> {}
-    impl<St: State> State for SetCountNotGoing<St> {
-        type CountNotGoing = Set<members::count_not_going>;
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Url = Set<members::url>;
         type CountInterested = St::CountInterested;
-        type Url = St::Url;
         type CountGoing = St::CountGoing;
+        type CountNotGoing = St::CountNotGoing;
     }
     ///State transition - sets the `count_interested` field to Set
     pub struct SetCountInterested<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCountInterested<St> {}
     impl<St: State> State for SetCountInterested<St> {
-        type CountNotGoing = St::CountNotGoing;
-        type CountInterested = Set<members::count_interested>;
         type Url = St::Url;
+        type CountInterested = Set<members::count_interested>;
         type CountGoing = St::CountGoing;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
         type CountNotGoing = St::CountNotGoing;
-        type CountInterested = St::CountInterested;
-        type Url = Set<members::url>;
-        type CountGoing = St::CountGoing;
     }
     ///State transition - sets the `count_going` field to Set
     pub struct SetCountGoing<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCountGoing<St> {}
     impl<St: State> State for SetCountGoing<St> {
-        type CountNotGoing = St::CountNotGoing;
-        type CountInterested = St::CountInterested;
         type Url = St::Url;
+        type CountInterested = St::CountInterested;
         type CountGoing = Set<members::count_going>;
+        type CountNotGoing = St::CountNotGoing;
+    }
+    ///State transition - sets the `count_not_going` field to Set
+    pub struct SetCountNotGoing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCountNotGoing<St> {}
+    impl<St: State> State for SetCountNotGoing<St> {
+        type Url = St::Url;
+        type CountInterested = St::CountInterested;
+        type CountGoing = St::CountGoing;
+        type CountNotGoing = Set<members::count_not_going>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `count_not_going` field
-        pub struct count_not_going(());
-        ///Marker type for the `count_interested` field
-        pub struct count_interested(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `count_interested` field
+        pub struct count_interested(());
         ///Marker type for the `count_going` field
         pub struct count_going(());
+        ///Marker type for the `count_not_going` field
+        pub struct count_not_going(());
     }
 }
 
@@ -319,10 +319,10 @@ where
 impl<S: BosStr, St> EventViewBuilder<S, St>
 where
     St: event_view_state::State,
-    St::CountNotGoing: event_view_state::IsSet,
-    St::CountInterested: event_view_state::IsSet,
     St::Url: event_view_state::IsSet,
+    St::CountInterested: event_view_state::IsSet,
     St::CountGoing: event_view_state::IsSet,
+    St::CountNotGoing: event_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EventView<S> {
@@ -472,37 +472,37 @@ pub mod get_event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repository;
         type RecordKey;
+        type Repository;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repository = Unset;
         type RecordKey = Unset;
-    }
-    ///State transition - sets the `repository` field to Set
-    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepository<St> {}
-    impl<St: State> State for SetRepository<St> {
-        type Repository = Set<members::repository>;
-        type RecordKey = St::RecordKey;
+        type Repository = Unset;
     }
     ///State transition - sets the `record_key` field to Set
     pub struct SetRecordKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecordKey<St> {}
     impl<St: State> State for SetRecordKey<St> {
-        type Repository = St::Repository;
         type RecordKey = Set<members::record_key>;
+        type Repository = St::Repository;
+    }
+    ///State transition - sets the `repository` field to Set
+    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepository<St> {}
+    impl<St: State> State for SetRepository<St> {
+        type RecordKey = St::RecordKey;
+        type Repository = Set<members::repository>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repository` field
-        pub struct repository(());
         ///Marker type for the `record_key` field
         pub struct record_key(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
     }
 }
 
@@ -572,8 +572,8 @@ where
 impl<S: BosStr, St> GetEventBuilder<S, St>
 where
     St: get_event_state::State,
-    St::Repository: get_event_state::IsSet,
     St::RecordKey: get_event_state::IsSet,
+    St::Repository: get_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetEvent<S> {
diff --git a/crates/jacquard-api/src/community_lexicon/calendar/get_rsvp.rs b/crates/jacquard-api/src/community_lexicon/calendar/get_rsvp.rs
index 7a698c7f..de97ed7e 100644
--- a/crates/jacquard-api/src/community_lexicon/calendar/get_rsvp.rs
+++ b/crates/jacquard-api/src/community_lexicon/calendar/get_rsvp.rs
@@ -115,37 +115,37 @@ pub mod get_rsvp_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Identity;
         type Event;
+        type Identity;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Identity = Unset;
         type Event = Unset;
-    }
-    ///State transition - sets the `identity` field to Set
-    pub struct SetIdentity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIdentity<St> {}
-    impl<St: State> State for SetIdentity<St> {
-        type Identity = Set<members::identity>;
-        type Event = St::Event;
+        type Identity = Unset;
     }
     ///State transition - sets the `event` field to Set
     pub struct SetEvent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvent<St> {}
     impl<St: State> State for SetEvent<St> {
-        type Identity = St::Identity;
         type Event = Set<members::event>;
+        type Identity = St::Identity;
+    }
+    ///State transition - sets the `identity` field to Set
+    pub struct SetIdentity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIdentity<St> {}
+    impl<St: State> State for SetIdentity<St> {
+        type Event = St::Event;
+        type Identity = Set<members::identity>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `identity` field
-        pub struct identity(());
         ///Marker type for the `event` field
         pub struct event(());
+        ///Marker type for the `identity` field
+        pub struct identity(());
     }
 }
 
@@ -215,8 +215,8 @@ where
 impl<S: BosStr, St> GetRsvpBuilder<S, St>
 where
     St: get_rsvp_state::State,
-    St::Identity: get_rsvp_state::IsSet,
     St::Event: get_rsvp_state::IsSet,
+    St::Identity: get_rsvp_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetRsvp<S> {
diff --git a/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs b/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs
index 373aae39..37c3e6fa 100644
--- a/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs
+++ b/crates/jacquard-api/src/community_lexicon/calendar/rsvp.rs
@@ -225,37 +225,37 @@ pub mod rsvp_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type Subject;
+        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type Subject = St::Subject;
+        type Status = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Status = St::Status;
         type Subject = Set<members::subject>;
+        type Status = St::Status;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Subject = St::Subject;
+        type Status = Set<members::status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `status` field
+        pub struct status(());
     }
 }
 
@@ -325,8 +325,8 @@ where
 impl<S: BosStr, St> RsvpBuilder<S, St>
 where
     St: rsvp_state::State,
-    St::Status: rsvp_state::IsSet,
     St::Subject: rsvp_state::IsSet,
+    St::Status: rsvp_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rsvp<S> {
diff --git a/crates/jacquard-api/src/community_lexicon/calendar/search_events.rs b/crates/jacquard-api/src/community_lexicon/calendar/search_events.rs
index 6bdcb2fa..d166c27b 100644
--- a/crates/jacquard-api/src/community_lexicon/calendar/search_events.rs
+++ b/crates/jacquard-api/src/community_lexicon/calendar/search_events.rs
@@ -177,67 +177,67 @@ pub mod event_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CountInterested;
+        type CountNotGoing;
         type Url;
+        type CountInterested;
         type CountGoing;
-        type CountNotGoing;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CountInterested = Unset;
+        type CountNotGoing = Unset;
         type Url = Unset;
+        type CountInterested = Unset;
         type CountGoing = Unset;
-        type CountNotGoing = Unset;
     }
-    ///State transition - sets the `count_interested` field to Set
-    pub struct SetCountInterested<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCountInterested<St> {}
-    impl<St: State> State for SetCountInterested<St> {
-        type CountInterested = Set<members::count_interested>;
+    ///State transition - sets the `count_not_going` field to Set
+    pub struct SetCountNotGoing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCountNotGoing<St> {}
+    impl<St: State> State for SetCountNotGoing<St> {
+        type CountNotGoing = Set<members::count_not_going>;
         type Url = St::Url;
+        type CountInterested = St::CountInterested;
         type CountGoing = St::CountGoing;
-        type CountNotGoing = St::CountNotGoing;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type CountInterested = St::CountInterested;
+        type CountNotGoing = St::CountNotGoing;
         type Url = Set<members::url>;
+        type CountInterested = St::CountInterested;
         type CountGoing = St::CountGoing;
+    }
+    ///State transition - sets the `count_interested` field to Set
+    pub struct SetCountInterested<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCountInterested<St> {}
+    impl<St: State> State for SetCountInterested<St> {
         type CountNotGoing = St::CountNotGoing;
+        type Url = St::Url;
+        type CountInterested = Set<members::count_interested>;
+        type CountGoing = St::CountGoing;
     }
     ///State transition - sets the `count_going` field to Set
     pub struct SetCountGoing<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCountGoing<St> {}
     impl<St: State> State for SetCountGoing<St> {
-        type CountInterested = St::CountInterested;
-        type Url = St::Url;
-        type CountGoing = Set<members::count_going>;
         type CountNotGoing = St::CountNotGoing;
-    }
-    ///State transition - sets the `count_not_going` field to Set
-    pub struct SetCountNotGoing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCountNotGoing<St> {}
-    impl<St: State> State for SetCountNotGoing<St> {
-        type CountInterested = St::CountInterested;
         type Url = St::Url;
-        type CountGoing = St::CountGoing;
-        type CountNotGoing = Set<members::count_not_going>;
+        type CountInterested = St::CountInterested;
+        type CountGoing = Set<members::count_going>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `count_interested` field
-        pub struct count_interested(());
+        ///Marker type for the `count_not_going` field
+        pub struct count_not_going(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `count_interested` field
+        pub struct count_interested(());
         ///Marker type for the `count_going` field
         pub struct count_going(());
-        ///Marker type for the `count_not_going` field
-        pub struct count_not_going(());
     }
 }
 
@@ -345,10 +345,10 @@ where
 impl<S: BosStr, St> EventViewBuilder<S, St>
 where
     St: event_view_state::State,
-    St::CountInterested: event_view_state::IsSet,
+    St::CountNotGoing: event_view_state::IsSet,
     St::Url: event_view_state::IsSet,
+    St::CountInterested: event_view_state::IsSet,
     St::CountGoing: event_view_state::IsSet,
-    St::CountNotGoing: event_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EventView<S> {
diff --git a/crates/jacquard-api/src/computer_aesthetic/kidlisp.rs b/crates/jacquard-api/src/computer_aesthetic/kidlisp.rs
index 65c5413d..ae2f40d6 100644
--- a/crates/jacquard-api/src/computer_aesthetic/kidlisp.rs
+++ b/crates/jacquard-api/src/computer_aesthetic/kidlisp.rs
@@ -152,66 +152,66 @@ pub mod kidlisp_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Source;
-        type Code;
         type Ref;
         type When;
+        type Code;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Source = Unset;
-        type Code = Unset;
         type Ref = Unset;
         type When = Unset;
+        type Code = Unset;
     }
     ///State transition - sets the `source` field to Set
     pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSource<St> {}
     impl<St: State> State for SetSource<St> {
         type Source = Set<members::source>;
-        type Code = St::Code;
-        type Ref = St::Ref;
-        type When = St::When;
-    }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
-        type Source = St::Source;
-        type Code = Set<members::code>;
         type Ref = St::Ref;
         type When = St::When;
+        type Code = St::Code;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
         type Source = St::Source;
-        type Code = St::Code;
         type Ref = Set<members::r#ref>;
         type When = St::When;
+        type Code = St::Code;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
         type Source = St::Source;
-        type Code = St::Code;
         type Ref = St::Ref;
         type When = Set<members::when>;
+        type Code = St::Code;
+    }
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
+        type Source = St::Source;
+        type Ref = St::Ref;
+        type When = St::When;
+        type Code = Set<members::code>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `source` field
         pub struct source(());
-        ///Marker type for the `code` field
-        pub struct code(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
         ///Marker type for the `when` field
         pub struct when(());
+        ///Marker type for the `code` field
+        pub struct code(());
     }
 }
 
@@ -320,9 +320,9 @@ impl<S: BosStr, St> KidlispBuilder<S, St>
 where
     St: kidlisp_state::State,
     St::Source: kidlisp_state::IsSet,
-    St::Code: kidlisp_state::IsSet,
     St::Ref: kidlisp_state::IsSet,
     St::When: kidlisp_state::IsSet,
+    St::Code: kidlisp_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Kidlisp<S> {
diff --git a/crates/jacquard-api/src/computer_aesthetic/mood.rs b/crates/jacquard-api/src/computer_aesthetic/mood.rs
index 060eb85a..a23a469f 100644
--- a/crates/jacquard-api/src/computer_aesthetic/mood.rs
+++ b/crates/jacquard-api/src/computer_aesthetic/mood.rs
@@ -127,51 +127,51 @@ pub mod mood_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Ref;
         type Mood;
         type When;
-        type Ref;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Ref = Unset;
         type Mood = Unset;
         type When = Unset;
-        type Ref = Unset;
+    }
+    ///State transition - sets the `ref` field to Set
+    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRef<St> {}
+    impl<St: State> State for SetRef<St> {
+        type Ref = Set<members::r#ref>;
+        type Mood = St::Mood;
+        type When = St::When;
     }
     ///State transition - sets the `mood` field to Set
     pub struct SetMood<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMood<St> {}
     impl<St: State> State for SetMood<St> {
+        type Ref = St::Ref;
         type Mood = Set<members::mood>;
         type When = St::When;
-        type Ref = St::Ref;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Mood = St::Mood;
-        type When = Set<members::when>;
         type Ref = St::Ref;
-    }
-    ///State transition - sets the `ref` field to Set
-    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRef<St> {}
-    impl<St: State> State for SetRef<St> {
         type Mood = St::Mood;
-        type When = St::When;
-        type Ref = Set<members::r#ref>;
+        type When = Set<members::when>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `ref` field
+        pub struct r#ref(());
         ///Marker type for the `mood` field
         pub struct mood(());
         ///Marker type for the `when` field
         pub struct when(());
-        ///Marker type for the `ref` field
-        pub struct r#ref(());
     }
 }
 
@@ -260,9 +260,9 @@ where
 impl<S: BosStr, St> MoodBuilder<S, St>
 where
     St: mood_state::State,
+    St::Ref: mood_state::IsSet,
     St::Mood: mood_state::IsSet,
     St::When: mood_state::IsSet,
-    St::Ref: mood_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Mood<S> {
diff --git a/crates/jacquard-api/src/computer_aesthetic/painting.rs b/crates/jacquard-api/src/computer_aesthetic/painting.rs
index 3e8880d8..6727e538 100644
--- a/crates/jacquard-api/src/computer_aesthetic/painting.rs
+++ b/crates/jacquard-api/src/computer_aesthetic/painting.rs
@@ -221,85 +221,85 @@ pub mod painting_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type When;
         type ImageUrl;
-        type Code;
-        type Ref;
         type Slug;
+        type When;
+        type Ref;
+        type Code;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type When = Unset;
         type ImageUrl = Unset;
-        type Code = Unset;
-        type Ref = Unset;
         type Slug = Unset;
-    }
-    ///State transition - sets the `when` field to Set
-    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWhen<St> {}
-    impl<St: State> State for SetWhen<St> {
-        type When = Set<members::when>;
-        type ImageUrl = St::ImageUrl;
-        type Code = St::Code;
-        type Ref = St::Ref;
-        type Slug = St::Slug;
+        type When = Unset;
+        type Ref = Unset;
+        type Code = Unset;
     }
     ///State transition - sets the `image_url` field to Set
     pub struct SetImageUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetImageUrl<St> {}
     impl<St: State> State for SetImageUrl<St> {
-        type When = St::When;
         type ImageUrl = Set<members::image_url>;
-        type Code = St::Code;
-        type Ref = St::Ref;
         type Slug = St::Slug;
-    }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
         type When = St::When;
+        type Ref = St::Ref;
+        type Code = St::Code;
+    }
+    ///State transition - sets the `slug` field to Set
+    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSlug<St> {}
+    impl<St: State> State for SetSlug<St> {
         type ImageUrl = St::ImageUrl;
-        type Code = Set<members::code>;
+        type Slug = Set<members::slug>;
+        type When = St::When;
         type Ref = St::Ref;
+        type Code = St::Code;
+    }
+    ///State transition - sets the `when` field to Set
+    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWhen<St> {}
+    impl<St: State> State for SetWhen<St> {
+        type ImageUrl = St::ImageUrl;
         type Slug = St::Slug;
+        type When = Set<members::when>;
+        type Ref = St::Ref;
+        type Code = St::Code;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type When = St::When;
         type ImageUrl = St::ImageUrl;
-        type Code = St::Code;
-        type Ref = Set<members::r#ref>;
         type Slug = St::Slug;
-    }
-    ///State transition - sets the `slug` field to Set
-    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSlug<St> {}
-    impl<St: State> State for SetSlug<St> {
         type When = St::When;
-        type ImageUrl = St::ImageUrl;
+        type Ref = Set<members::r#ref>;
         type Code = St::Code;
+    }
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
+        type ImageUrl = St::ImageUrl;
+        type Slug = St::Slug;
+        type When = St::When;
         type Ref = St::Ref;
-        type Slug = Set<members::slug>;
+        type Code = Set<members::code>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `when` field
-        pub struct when(());
         ///Marker type for the `image_url` field
         pub struct image_url(());
-        ///Marker type for the `code` field
-        pub struct code(());
-        ///Marker type for the `ref` field
-        pub struct r#ref(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `when` field
+        pub struct when(());
+        ///Marker type for the `ref` field
+        pub struct r#ref(());
+        ///Marker type for the `code` field
+        pub struct code(());
     }
 }
 
@@ -460,11 +460,11 @@ where
 impl<S: BosStr, St> PaintingBuilder<S, St>
 where
     St: painting_state::State,
-    St::When: painting_state::IsSet,
     St::ImageUrl: painting_state::IsSet,
-    St::Code: painting_state::IsSet,
-    St::Ref: painting_state::IsSet,
     St::Slug: painting_state::IsSet,
+    St::When: painting_state::IsSet,
+    St::Ref: painting_state::IsSet,
+    St::Code: painting_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Painting<S> {
diff --git a/crates/jacquard-api/src/computer_aesthetic/piece.rs b/crates/jacquard-api/src/computer_aesthetic/piece.rs
index edccf558..7f9b221f 100644
--- a/crates/jacquard-api/src/computer_aesthetic/piece.rs
+++ b/crates/jacquard-api/src/computer_aesthetic/piece.rs
@@ -138,51 +138,51 @@ pub mod piece_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type When;
         type Ref;
         type Slug;
+        type When;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type When = Unset;
         type Ref = Unset;
         type Slug = Unset;
-    }
-    ///State transition - sets the `when` field to Set
-    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWhen<St> {}
-    impl<St: State> State for SetWhen<St> {
-        type When = Set<members::when>;
-        type Ref = St::Ref;
-        type Slug = St::Slug;
+        type When = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type When = St::When;
         type Ref = Set<members::r#ref>;
         type Slug = St::Slug;
+        type When = St::When;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlug<St> {}
     impl<St: State> State for SetSlug<St> {
-        type When = St::When;
         type Ref = St::Ref;
         type Slug = Set<members::slug>;
+        type When = St::When;
+    }
+    ///State transition - sets the `when` field to Set
+    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWhen<St> {}
+    impl<St: State> State for SetWhen<St> {
+        type Ref = St::Ref;
+        type Slug = St::Slug;
+        type When = Set<members::when>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `when` field
-        pub struct when(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `when` field
+        pub struct when(());
     }
 }
 
@@ -271,9 +271,9 @@ where
 impl<S: BosStr, St> PieceBuilder<S, St>
 where
     St: piece_state::State,
-    St::When: piece_state::IsSet,
     St::Ref: piece_state::IsSet,
     St::Slug: piece_state::IsSet,
+    St::When: piece_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Piece<S> {
diff --git a/crates/jacquard-api/src/computer_aesthetic/tape.rs b/crates/jacquard-api/src/computer_aesthetic/tape.rs
index d56e55f6..d844e15d 100644
--- a/crates/jacquard-api/src/computer_aesthetic/tape.rs
+++ b/crates/jacquard-api/src/computer_aesthetic/tape.rs
@@ -209,51 +209,51 @@ pub mod tape_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type When;
-        type Code;
         type Slug;
+        type Code;
+        type When;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type When = Unset;
-        type Code = Unset;
         type Slug = Unset;
+        type Code = Unset;
+        type When = Unset;
     }
-    ///State transition - sets the `when` field to Set
-    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWhen<St> {}
-    impl<St: State> State for SetWhen<St> {
-        type When = Set<members::when>;
+    ///State transition - sets the `slug` field to Set
+    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSlug<St> {}
+    impl<St: State> State for SetSlug<St> {
+        type Slug = Set<members::slug>;
         type Code = St::Code;
-        type Slug = St::Slug;
+        type When = St::When;
     }
     ///State transition - sets the `code` field to Set
     pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCode<St> {}
     impl<St: State> State for SetCode<St> {
-        type When = St::When;
-        type Code = Set<members::code>;
         type Slug = St::Slug;
-    }
-    ///State transition - sets the `slug` field to Set
-    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSlug<St> {}
-    impl<St: State> State for SetSlug<St> {
+        type Code = Set<members::code>;
         type When = St::When;
+    }
+    ///State transition - sets the `when` field to Set
+    pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWhen<St> {}
+    impl<St: State> State for SetWhen<St> {
+        type Slug = St::Slug;
         type Code = St::Code;
-        type Slug = Set<members::slug>;
+        type When = Set<members::when>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `when` field
-        pub struct when(());
-        ///Marker type for the `code` field
-        pub struct code(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `code` field
+        pub struct code(());
+        ///Marker type for the `when` field
+        pub struct when(());
     }
 }
 
@@ -416,9 +416,9 @@ impl<S: BosStr, St: tape_state::State> TapeBuilder<S, St> {
 impl<S: BosStr, St> TapeBuilder<S, St>
 where
     St: tape_state::State,
-    St::When: tape_state::IsSet,
-    St::Code: tape_state::IsSet,
     St::Slug: tape_state::IsSet,
+    St::Code: tape_state::IsSet,
+    St::When: tape_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Tape<S> {
diff --git a/crates/jacquard-api/src/coop_hypha/pollen/claim.rs b/crates/jacquard-api/src/coop_hypha/pollen/claim.rs
index 774f4ebf..bb0bf504 100644
--- a/crates/jacquard-api/src/coop_hypha/pollen/claim.rs
+++ b/crates/jacquard-api/src/coop_hypha/pollen/claim.rs
@@ -123,67 +123,67 @@ pub mod claim_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Cid;
-        type Content;
         type Pfp;
+        type Content;
+        type Cid;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Cid = Unset;
-        type Content = Unset;
         type Pfp = Unset;
+        type Content = Unset;
+        type Cid = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Cid = St::Cid;
+    ///State transition - sets the `pfp` field to Set
+    pub struct SetPfp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPfp<St> {}
+    impl<St: State> State for SetPfp<St> {
+        type Pfp = Set<members::pfp>;
         type Content = St::Content;
-        type Pfp = St::Pfp;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
-        type Cid = Set<members::cid>;
-        type Content = St::Content;
-        type Pfp = St::Pfp;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type CreatedAt = St::CreatedAt;
-        type Cid = St::Cid;
-        type Content = Set<members::content>;
         type Pfp = St::Pfp;
+        type Content = Set<members::content>;
+        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `pfp` field to Set
-    pub struct SetPfp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPfp<St> {}
-    impl<St: State> State for SetPfp<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Pfp = St::Pfp;
+        type Content = St::Content;
+        type Cid = Set<members::cid>;
         type CreatedAt = St::CreatedAt;
-        type Cid = St::Cid;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Pfp = St::Pfp;
         type Content = St::Content;
-        type Pfp = Set<members::pfp>;
+        type Cid = St::Cid;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `content` field
-        pub struct content(());
         ///Marker type for the `pfp` field
         pub struct pfp(());
+        ///Marker type for the `content` field
+        pub struct content(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -310,10 +310,10 @@ impl<S: BosStr, St: claim_state::State> ClaimBuilder<S, St> {
 impl<S: BosStr, St> ClaimBuilder<S, St>
 where
     St: claim_state::State,
-    St::CreatedAt: claim_state::IsSet,
-    St::Cid: claim_state::IsSet,
-    St::Content: claim_state::IsSet,
     St::Pfp: claim_state::IsSet,
+    St::Content: claim_state::IsSet,
+    St::Cid: claim_state::IsSet,
+    St::CreatedAt: claim_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Claim<S> {
diff --git a/crates/jacquard-api/src/coop_hypha/spores/content/text.rs b/crates/jacquard-api/src/coop_hypha/spores/content/text.rs
index 46cb1637..ac7056af 100644
--- a/crates/jacquard-api/src/coop_hypha/spores/content/text.rs
+++ b/crates/jacquard-api/src/coop_hypha/spores/content/text.rs
@@ -249,37 +249,37 @@ pub mod text_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Content;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Content = St::Content;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type CreatedAt = St::CreatedAt;
         type Content = Set<members::content>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Content = St::Content;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -375,8 +375,8 @@ impl<S: BosStr, St: text_state::State> TextBuilder<S, St> {
 impl<S: BosStr, St> TextBuilder<S, St>
 where
     St: text_state::State,
-    St::CreatedAt: text_state::IsSet,
     St::Content: text_state::IsSet,
+    St::CreatedAt: text_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Text<S> {
diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs b/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs
index d3f48bd4..bd4618af 100644
--- a/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs
+++ b/crates/jacquard-api/src/dev_baileytownsend/health/calories.rs
@@ -113,51 +113,51 @@ pub mod calories_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Intake;
         type Burned;
         type CreatedAt;
-        type Intake;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Intake = Unset;
         type Burned = Unset;
         type CreatedAt = Unset;
-        type Intake = Unset;
+    }
+    ///State transition - sets the `intake` field to Set
+    pub struct SetIntake<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIntake<St> {}
+    impl<St: State> State for SetIntake<St> {
+        type Intake = Set<members::intake>;
+        type Burned = St::Burned;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `burned` field to Set
     pub struct SetBurned<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBurned<St> {}
     impl<St: State> State for SetBurned<St> {
+        type Intake = St::Intake;
         type Burned = Set<members::burned>;
         type CreatedAt = St::CreatedAt;
-        type Intake = St::Intake;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Burned = St::Burned;
-        type CreatedAt = Set<members::created_at>;
         type Intake = St::Intake;
-    }
-    ///State transition - sets the `intake` field to Set
-    pub struct SetIntake<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIntake<St> {}
-    impl<St: State> State for SetIntake<St> {
         type Burned = St::Burned;
-        type CreatedAt = St::CreatedAt;
-        type Intake = Set<members::intake>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `intake` field
+        pub struct intake(());
         ///Marker type for the `burned` field
         pub struct burned(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `intake` field
-        pub struct intake(());
     }
 }
 
@@ -246,9 +246,9 @@ where
 impl<S: BosStr, St> CaloriesBuilder<S, St>
 where
     St: calories_state::State,
+    St::Intake: calories_state::IsSet,
     St::Burned: calories_state::IsSet,
     St::CreatedAt: calories_state::IsSet,
-    St::Intake: calories_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Calories<S> {
diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs b/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs
index 762fdb61..e201488d 100644
--- a/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs
+++ b/crates/jacquard-api/src/dev_baileytownsend/health/rings.rs
@@ -123,127 +123,127 @@ pub mod rings_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Exercise;
-        type ExerciseGoal;
-        type StandHours;
         type StandGoal;
         type CreatedAt;
+        type StandHours;
+        type Exercise;
         type Move;
         type MoveGoal;
+        type ExerciseGoal;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Exercise = Unset;
-        type ExerciseGoal = Unset;
-        type StandHours = Unset;
         type StandGoal = Unset;
         type CreatedAt = Unset;
+        type StandHours = Unset;
+        type Exercise = Unset;
         type Move = Unset;
         type MoveGoal = Unset;
+        type ExerciseGoal = Unset;
     }
-    ///State transition - sets the `exercise` field to Set
-    pub struct SetExercise<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetExercise<St> {}
-    impl<St: State> State for SetExercise<St> {
-        type Exercise = Set<members::exercise>;
-        type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
-        type StandGoal = St::StandGoal;
+    ///State transition - sets the `stand_goal` field to Set
+    pub struct SetStandGoal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStandGoal<St> {}
+    impl<St: State> State for SetStandGoal<St> {
+        type StandGoal = Set<members::stand_goal>;
         type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
+        type Exercise = St::Exercise;
         type Move = St::Move;
         type MoveGoal = St::MoveGoal;
+        type ExerciseGoal = St::ExerciseGoal;
     }
-    ///State transition - sets the `exercise_goal` field to Set
-    pub struct SetExerciseGoal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetExerciseGoal<St> {}
-    impl<St: State> State for SetExerciseGoal<St> {
-        type Exercise = St::Exercise;
-        type ExerciseGoal = Set<members::exercise_goal>;
-        type StandHours = St::StandHours;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
+        type CreatedAt = Set<members::created_at>;
+        type StandHours = St::StandHours;
+        type Exercise = St::Exercise;
         type Move = St::Move;
         type MoveGoal = St::MoveGoal;
+        type ExerciseGoal = St::ExerciseGoal;
     }
     ///State transition - sets the `stand_hours` field to Set
     pub struct SetStandHours<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStandHours<St> {}
     impl<St: State> State for SetStandHours<St> {
-        type Exercise = St::Exercise;
-        type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = Set<members::stand_hours>;
         type StandGoal = St::StandGoal;
         type CreatedAt = St::CreatedAt;
-        type Move = St::Move;
-        type MoveGoal = St::MoveGoal;
-    }
-    ///State transition - sets the `stand_goal` field to Set
-    pub struct SetStandGoal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStandGoal<St> {}
-    impl<St: State> State for SetStandGoal<St> {
+        type StandHours = Set<members::stand_hours>;
         type Exercise = St::Exercise;
-        type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
-        type StandGoal = Set<members::stand_goal>;
-        type CreatedAt = St::CreatedAt;
         type Move = St::Move;
         type MoveGoal = St::MoveGoal;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Exercise = St::Exercise;
         type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
+    }
+    ///State transition - sets the `exercise` field to Set
+    pub struct SetExercise<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetExercise<St> {}
+    impl<St: State> State for SetExercise<St> {
         type StandGoal = St::StandGoal;
-        type CreatedAt = Set<members::created_at>;
+        type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
+        type Exercise = Set<members::exercise>;
         type Move = St::Move;
         type MoveGoal = St::MoveGoal;
+        type ExerciseGoal = St::ExerciseGoal;
     }
     ///State transition - sets the `move` field to Set
     pub struct SetMove<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMove<St> {}
     impl<St: State> State for SetMove<St> {
-        type Exercise = St::Exercise;
-        type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
         type StandGoal = St::StandGoal;
         type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
+        type Exercise = St::Exercise;
         type Move = Set<members::r#move>;
         type MoveGoal = St::MoveGoal;
+        type ExerciseGoal = St::ExerciseGoal;
     }
     ///State transition - sets the `move_goal` field to Set
     pub struct SetMoveGoal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMoveGoal<St> {}
     impl<St: State> State for SetMoveGoal<St> {
+        type StandGoal = St::StandGoal;
+        type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
         type Exercise = St::Exercise;
+        type Move = St::Move;
+        type MoveGoal = Set<members::move_goal>;
         type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
+    }
+    ///State transition - sets the `exercise_goal` field to Set
+    pub struct SetExerciseGoal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetExerciseGoal<St> {}
+    impl<St: State> State for SetExerciseGoal<St> {
         type StandGoal = St::StandGoal;
         type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
+        type Exercise = St::Exercise;
         type Move = St::Move;
-        type MoveGoal = Set<members::move_goal>;
+        type MoveGoal = St::MoveGoal;
+        type ExerciseGoal = Set<members::exercise_goal>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `exercise` field
-        pub struct exercise(());
-        ///Marker type for the `exercise_goal` field
-        pub struct exercise_goal(());
-        ///Marker type for the `stand_hours` field
-        pub struct stand_hours(());
         ///Marker type for the `stand_goal` field
         pub struct stand_goal(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `stand_hours` field
+        pub struct stand_hours(());
+        ///Marker type for the `exercise` field
+        pub struct exercise(());
         ///Marker type for the `move` field
         pub struct r#move(());
         ///Marker type for the `move_goal` field
         pub struct move_goal(());
+        ///Marker type for the `exercise_goal` field
+        pub struct exercise_goal(());
     }
 }
 
@@ -416,13 +416,13 @@ where
 impl<S: BosStr, St> RingsBuilder<S, St>
 where
     St: rings_state::State,
-    St::Exercise: rings_state::IsSet,
-    St::ExerciseGoal: rings_state::IsSet,
-    St::StandHours: rings_state::IsSet,
     St::StandGoal: rings_state::IsSet,
     St::CreatedAt: rings_state::IsSet,
+    St::StandHours: rings_state::IsSet,
+    St::Exercise: rings_state::IsSet,
     St::Move: rings_state::IsSet,
     St::MoveGoal: rings_state::IsSet,
+    St::ExerciseGoal: rings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rings<S> {
diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs b/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs
index e16b45fc..c2fc6667 100644
--- a/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs
+++ b/crates/jacquard-api/src/dev_baileytownsend/health/steps.rs
@@ -111,37 +111,37 @@ pub mod steps_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Steps;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Steps = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Steps = St::Steps;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `steps` field to Set
     pub struct SetSteps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSteps<St> {}
     impl<St: State> State for SetSteps<St> {
-        type CreatedAt = St::CreatedAt;
         type Steps = Set<members::steps>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Steps = St::Steps;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `steps` field
         pub struct steps(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -211,8 +211,8 @@ where
 impl<S: BosStr, St> StepsBuilder<S, St>
 where
     St: steps_state::State,
-    St::CreatedAt: steps_state::IsSet,
     St::Steps: steps_state::IsSet,
+    St::CreatedAt: steps_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Steps<S> {
diff --git a/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs b/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs
index 903f2a59..9e69dc1f 100644
--- a/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs
+++ b/crates/jacquard-api/src/dev_baileytownsend/health/workout.rs
@@ -121,105 +121,105 @@ pub mod workout_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Activity;
-        type EndTime;
-        type Duration;
-        type StartTime;
         type CreatedAt;
         type CaloriesBurned;
+        type Duration;
+        type EndTime;
+        type StartTime;
+        type Activity;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Activity = Unset;
-        type EndTime = Unset;
-        type Duration = Unset;
-        type StartTime = Unset;
         type CreatedAt = Unset;
         type CaloriesBurned = Unset;
+        type Duration = Unset;
+        type EndTime = Unset;
+        type StartTime = Unset;
+        type Activity = Unset;
     }
-    ///State transition - sets the `activity` field to Set
-    pub struct SetActivity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActivity<St> {}
-    impl<St: State> State for SetActivity<St> {
-        type Activity = Set<members::activity>;
-        type EndTime = St::EndTime;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type CaloriesBurned = St::CaloriesBurned;
         type Duration = St::Duration;
+        type EndTime = St::EndTime;
         type StartTime = St::StartTime;
-        type CreatedAt = St::CreatedAt;
-        type CaloriesBurned = St::CaloriesBurned;
-    }
-    ///State transition - sets the `end_time` field to Set
-    pub struct SetEndTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEndTime<St> {}
-    impl<St: State> State for SetEndTime<St> {
         type Activity = St::Activity;
-        type EndTime = Set<members::end_time>;
+    }
+    ///State transition - sets the `calories_burned` field to Set
+    pub struct SetCaloriesBurned<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCaloriesBurned<St> {}
+    impl<St: State> State for SetCaloriesBurned<St> {
+        type CreatedAt = St::CreatedAt;
+        type CaloriesBurned = Set<members::calories_burned>;
         type Duration = St::Duration;
+        type EndTime = St::EndTime;
         type StartTime = St::StartTime;
-        type CreatedAt = St::CreatedAt;
-        type CaloriesBurned = St::CaloriesBurned;
+        type Activity = St::Activity;
     }
     ///State transition - sets the `duration` field to Set
     pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDuration<St> {}
     impl<St: State> State for SetDuration<St> {
-        type Activity = St::Activity;
-        type EndTime = St::EndTime;
+        type CreatedAt = St::CreatedAt;
+        type CaloriesBurned = St::CaloriesBurned;
         type Duration = Set<members::duration>;
+        type EndTime = St::EndTime;
         type StartTime = St::StartTime;
+        type Activity = St::Activity;
+    }
+    ///State transition - sets the `end_time` field to Set
+    pub struct SetEndTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEndTime<St> {}
+    impl<St: State> State for SetEndTime<St> {
         type CreatedAt = St::CreatedAt;
         type CaloriesBurned = St::CaloriesBurned;
+        type Duration = St::Duration;
+        type EndTime = Set<members::end_time>;
+        type StartTime = St::StartTime;
+        type Activity = St::Activity;
     }
     ///State transition - sets the `start_time` field to Set
     pub struct SetStartTime<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStartTime<St> {}
     impl<St: State> State for SetStartTime<St> {
-        type Activity = St::Activity;
-        type EndTime = St::EndTime;
+        type CreatedAt = St::CreatedAt;
+        type CaloriesBurned = St::CaloriesBurned;
         type Duration = St::Duration;
+        type EndTime = St::EndTime;
         type StartTime = Set<members::start_time>;
+        type Activity = St::Activity;
+    }
+    ///State transition - sets the `activity` field to Set
+    pub struct SetActivity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActivity<St> {}
+    impl<St: State> State for SetActivity<St> {
         type CreatedAt = St::CreatedAt;
         type CaloriesBurned = St::CaloriesBurned;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Activity = St::Activity;
-        type EndTime = St::EndTime;
         type Duration = St::Duration;
-        type StartTime = St::StartTime;
-        type CreatedAt = Set<members::created_at>;
-        type CaloriesBurned = St::CaloriesBurned;
-    }
-    ///State transition - sets the `calories_burned` field to Set
-    pub struct SetCaloriesBurned<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCaloriesBurned<St> {}
-    impl<St: State> State for SetCaloriesBurned<St> {
-        type Activity = St::Activity;
         type EndTime = St::EndTime;
-        type Duration = St::Duration;
         type StartTime = St::StartTime;
-        type CreatedAt = St::CreatedAt;
-        type CaloriesBurned = Set<members::calories_burned>;
+        type Activity = Set<members::activity>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `activity` field
-        pub struct activity(());
-        ///Marker type for the `end_time` field
-        pub struct end_time(());
-        ///Marker type for the `duration` field
-        pub struct duration(());
-        ///Marker type for the `start_time` field
-        pub struct start_time(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `calories_burned` field
         pub struct calories_burned(());
+        ///Marker type for the `duration` field
+        pub struct duration(());
+        ///Marker type for the `end_time` field
+        pub struct end_time(());
+        ///Marker type for the `start_time` field
+        pub struct start_time(());
+        ///Marker type for the `activity` field
+        pub struct activity(());
     }
 }
 
@@ -386,12 +386,12 @@ where
 impl<S: BosStr, St> WorkoutBuilder<S, St>
 where
     St: workout_state::State,
-    St::Activity: workout_state::IsSet,
-    St::EndTime: workout_state::IsSet,
-    St::Duration: workout_state::IsSet,
-    St::StartTime: workout_state::IsSet,
     St::CreatedAt: workout_state::IsSet,
     St::CaloriesBurned: workout_state::IsSet,
+    St::Duration: workout_state::IsSet,
+    St::EndTime: workout_state::IsSet,
+    St::StartTime: workout_state::IsSet,
+    St::Activity: workout_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Workout<S> {
diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs
index 958f8818..8c83091b 100644
--- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs
+++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/post.rs
@@ -176,105 +176,105 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Category;
-        type Content;
         type Title;
         type Forum;
-        type Tags;
         type CreatedAt;
+        type Content;
+        type Category;
+        type Tags;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Category = Unset;
-        type Content = Unset;
         type Title = Unset;
         type Forum = Unset;
-        type Tags = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `category` field to Set
-    pub struct SetCategory<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCategory<St> {}
-    impl<St: State> State for SetCategory<St> {
-        type Category = Set<members::category>;
-        type Content = St::Content;
-        type Title = St::Title;
-        type Forum = St::Forum;
-        type Tags = St::Tags;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Category = St::Category;
-        type Content = Set<members::content>;
-        type Title = St::Title;
-        type Forum = St::Forum;
-        type Tags = St::Tags;
-        type CreatedAt = St::CreatedAt;
+        type Content = Unset;
+        type Category = Unset;
+        type Tags = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Category = St::Category;
-        type Content = St::Content;
         type Title = Set<members::title>;
         type Forum = St::Forum;
-        type Tags = St::Tags;
         type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
+        type Category = St::Category;
+        type Tags = St::Tags;
     }
     ///State transition - sets the `forum` field to Set
     pub struct SetForum<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetForum<St> {}
     impl<St: State> State for SetForum<St> {
+        type Title = St::Title;
+        type Forum = Set<members::forum>;
+        type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
         type Category = St::Category;
+        type Tags = St::Tags;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type Forum = St::Forum;
+        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
+        type Category = St::Category;
+        type Tags = St::Tags;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
         type Title = St::Title;
-        type Forum = Set<members::forum>;
+        type Forum = St::Forum;
+        type CreatedAt = St::CreatedAt;
+        type Content = Set<members::content>;
+        type Category = St::Category;
         type Tags = St::Tags;
+    }
+    ///State transition - sets the `category` field to Set
+    pub struct SetCategory<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCategory<St> {}
+    impl<St: State> State for SetCategory<St> {
+        type Title = St::Title;
+        type Forum = St::Forum;
         type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
+        type Category = Set<members::category>;
+        type Tags = St::Tags;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
-        type Category = St::Category;
-        type Content = St::Content;
         type Title = St::Title;
         type Forum = St::Forum;
-        type Tags = Set<members::tags>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Category = St::Category;
         type Content = St::Content;
-        type Title = St::Title;
-        type Forum = St::Forum;
-        type Tags = St::Tags;
-        type CreatedAt = Set<members::created_at>;
+        type Category = St::Category;
+        type Tags = Set<members::tags>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `category` field
-        pub struct category(());
-        ///Marker type for the `content` field
-        pub struct content(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `forum` field
         pub struct forum(());
-        ///Marker type for the `tags` field
-        pub struct tags(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `content` field
+        pub struct content(());
+        ///Marker type for the `category` field
+        pub struct category(());
+        ///Marker type for the `tags` field
+        pub struct tags(());
     }
 }
 
@@ -455,12 +455,12 @@ impl<S: BosStr, St: post_state::State> PostBuilder<S, St> {
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
-    St::Category: post_state::IsSet,
-    St::Content: post_state::IsSet,
     St::Title: post_state::IsSet,
     St::Forum: post_state::IsSet,
-    St::Tags: post_state::IsSet,
     St::CreatedAt: post_state::IsSet,
+    St::Content: post_state::IsSet,
+    St::Category: post_state::IsSet,
+    St::Tags: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/question.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/question.rs
index f978909a..797e5ce6 100644
--- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/question.rs
+++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/question.rs
@@ -174,105 +174,105 @@ pub mod question_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Forum;
-        type IsOpen;
+        type CreatedAt;
         type Content;
         type Tags;
         type Title;
-        type CreatedAt;
+        type Forum;
+        type IsOpen;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Forum = Unset;
-        type IsOpen = Unset;
+        type CreatedAt = Unset;
         type Content = Unset;
         type Tags = Unset;
         type Title = Unset;
-        type CreatedAt = Unset;
+        type Forum = Unset;
+        type IsOpen = Unset;
     }
-    ///State transition - sets the `forum` field to Set
-    pub struct SetForum<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetForum<St> {}
-    impl<St: State> State for SetForum<St> {
-        type Forum = Set<members::forum>;
-        type IsOpen = St::IsOpen;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
         type Tags = St::Tags;
         type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `is_open` field to Set
-    pub struct SetIsOpen<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIsOpen<St> {}
-    impl<St: State> State for SetIsOpen<St> {
         type Forum = St::Forum;
-        type IsOpen = Set<members::is_open>;
-        type Content = St::Content;
-        type Tags = St::Tags;
-        type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
+        type IsOpen = St::IsOpen;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Forum = St::Forum;
-        type IsOpen = St::IsOpen;
+        type CreatedAt = St::CreatedAt;
         type Content = Set<members::content>;
         type Tags = St::Tags;
         type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
+        type Forum = St::Forum;
+        type IsOpen = St::IsOpen;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
-        type Forum = St::Forum;
-        type IsOpen = St::IsOpen;
+        type CreatedAt = St::CreatedAt;
         type Content = St::Content;
         type Tags = Set<members::tags>;
         type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
+        type Forum = St::Forum;
+        type IsOpen = St::IsOpen;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Forum = St::Forum;
-        type IsOpen = St::IsOpen;
+        type CreatedAt = St::CreatedAt;
         type Content = St::Content;
         type Tags = St::Tags;
         type Title = Set<members::title>;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Forum = St::Forum;
         type IsOpen = St::IsOpen;
+    }
+    ///State transition - sets the `forum` field to Set
+    pub struct SetForum<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetForum<St> {}
+    impl<St: State> State for SetForum<St> {
+        type CreatedAt = St::CreatedAt;
         type Content = St::Content;
         type Tags = St::Tags;
         type Title = St::Title;
-        type CreatedAt = Set<members::created_at>;
+        type Forum = Set<members::forum>;
+        type IsOpen = St::IsOpen;
+    }
+    ///State transition - sets the `is_open` field to Set
+    pub struct SetIsOpen<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIsOpen<St> {}
+    impl<St: State> State for SetIsOpen<St> {
+        type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
+        type Tags = St::Tags;
+        type Title = St::Title;
+        type Forum = St::Forum;
+        type IsOpen = Set<members::is_open>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `forum` field
-        pub struct forum(());
-        ///Marker type for the `is_open` field
-        pub struct is_open(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
         ///Marker type for the `tags` field
         pub struct tags(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `forum` field
+        pub struct forum(());
+        ///Marker type for the `is_open` field
+        pub struct is_open(());
     }
 }
 
@@ -439,12 +439,12 @@ impl<S: BosStr, St: question_state::State> QuestionBuilder<S, St> {
 impl<S: BosStr, St> QuestionBuilder<S, St>
 where
     St: question_state::State,
-    St::Forum: question_state::IsSet,
-    St::IsOpen: question_state::IsSet,
+    St::CreatedAt: question_state::IsSet,
     St::Content: question_state::IsSet,
     St::Tags: question_state::IsSet,
     St::Title: question_state::IsSet,
-    St::CreatedAt: question_state::IsSet,
+    St::Forum: question_state::IsSet,
+    St::IsOpen: question_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Question<S> {
diff --git a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs
index 7443a441..e63d52a2 100644
--- a/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs
+++ b/crates/jacquard-api/src/dev_fudgeu/experimental/atforumv1/feed/reply.rs
@@ -126,51 +126,51 @@ pub mod reply_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Root;
         type CreatedAt;
         type Content;
+        type Root;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Root = Unset;
         type CreatedAt = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `root` field to Set
-    pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRoot<St> {}
-    impl<St: State> State for SetRoot<St> {
-        type Root = Set<members::root>;
-        type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
+        type Root = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Root = St::Root;
         type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
+        type Root = St::Root;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Root = St::Root;
         type CreatedAt = St::CreatedAt;
         type Content = Set<members::content>;
+        type Root = St::Root;
+    }
+    ///State transition - sets the `root` field to Set
+    pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRoot<St> {}
+    impl<St: State> State for SetRoot<St> {
+        type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
+        type Root = Set<members::root>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `root` field
-        pub struct root(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `root` field
+        pub struct root(());
     }
 }
 
@@ -272,9 +272,9 @@ impl<S: BosStr, St: reply_state::State> ReplyBuilder<S, St> {
 impl<S: BosStr, St> ReplyBuilder<S, St>
 where
     St: reply_state::State,
-    St::Root: reply_state::IsSet,
     St::CreatedAt: reply_state::IsSet,
     St::Content: reply_state::IsSet,
+    St::Root: reply_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reply<S> {
diff --git a/crates/jacquard-api/src/dev_kanad/lexicon_test_2026_02_26/example_cat_lexicon.rs b/crates/jacquard-api/src/dev_kanad/lexicon_test_2026_02_26/example_cat_lexicon.rs
index 379c217f..05e7aa35 100644
--- a/crates/jacquard-api/src/dev_kanad/lexicon_test_2026_02_26/example_cat_lexicon.rs
+++ b/crates/jacquard-api/src/dev_kanad/lexicon_test_2026_02_26/example_cat_lexicon.rs
@@ -192,37 +192,37 @@ pub mod example_cat_lexicon_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -305,8 +305,8 @@ where
 impl<S: BosStr, St> ExampleCatLexiconBuilder<S, St>
 where
     St: example_cat_lexicon_state::State,
-    St::Name: example_cat_lexicon_state::IsSet,
     St::CreatedAt: example_cat_lexicon_state::IsSet,
+    St::Name: example_cat_lexicon_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ExampleCatLexicon<S> {
diff --git a/crates/jacquard-api/src/dev_keytrace/claim.rs b/crates/jacquard-api/src/dev_keytrace/claim.rs
index dfcc42a4..a42f081b 100644
--- a/crates/jacquard-api/src/dev_keytrace/claim.rs
+++ b/crates/jacquard-api/src/dev_keytrace/claim.rs
@@ -633,85 +633,85 @@ pub mod claim_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type ClaimUri;
-        type Sigs;
-        type CreatedAt;
+        type Type;
         type Identity;
+        type CreatedAt;
+        type Sigs;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type ClaimUri = Unset;
-        type Sigs = Unset;
-        type CreatedAt = Unset;
+        type Type = Unset;
         type Identity = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type ClaimUri = St::ClaimUri;
-        type Sigs = St::Sigs;
-        type CreatedAt = St::CreatedAt;
-        type Identity = St::Identity;
+        type CreatedAt = Unset;
+        type Sigs = Unset;
     }
     ///State transition - sets the `claim_uri` field to Set
     pub struct SetClaimUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClaimUri<St> {}
     impl<St: State> State for SetClaimUri<St> {
-        type Type = St::Type;
         type ClaimUri = Set<members::claim_uri>;
-        type Sigs = St::Sigs;
+        type Type = St::Type;
+        type Identity = St::Identity;
         type CreatedAt = St::CreatedAt;
+        type Sigs = St::Sigs;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type ClaimUri = St::ClaimUri;
+        type Type = Set<members::r#type>;
         type Identity = St::Identity;
+        type CreatedAt = St::CreatedAt;
+        type Sigs = St::Sigs;
     }
-    ///State transition - sets the `sigs` field to Set
-    pub struct SetSigs<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSigs<St> {}
-    impl<St: State> State for SetSigs<St> {
-        type Type = St::Type;
+    ///State transition - sets the `identity` field to Set
+    pub struct SetIdentity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIdentity<St> {}
+    impl<St: State> State for SetIdentity<St> {
         type ClaimUri = St::ClaimUri;
-        type Sigs = Set<members::sigs>;
+        type Type = St::Type;
+        type Identity = Set<members::identity>;
         type CreatedAt = St::CreatedAt;
-        type Identity = St::Identity;
+        type Sigs = St::Sigs;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Type = St::Type;
         type ClaimUri = St::ClaimUri;
-        type Sigs = St::Sigs;
-        type CreatedAt = Set<members::created_at>;
+        type Type = St::Type;
         type Identity = St::Identity;
+        type CreatedAt = Set<members::created_at>;
+        type Sigs = St::Sigs;
     }
-    ///State transition - sets the `identity` field to Set
-    pub struct SetIdentity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIdentity<St> {}
-    impl<St: State> State for SetIdentity<St> {
-        type Type = St::Type;
+    ///State transition - sets the `sigs` field to Set
+    pub struct SetSigs<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSigs<St> {}
+    impl<St: State> State for SetSigs<St> {
         type ClaimUri = St::ClaimUri;
-        type Sigs = St::Sigs;
+        type Type = St::Type;
+        type Identity = St::Identity;
         type CreatedAt = St::CreatedAt;
-        type Identity = Set<members::identity>;
+        type Sigs = Set<members::sigs>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `claim_uri` field
         pub struct claim_uri(());
-        ///Marker type for the `sigs` field
-        pub struct sigs(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
         ///Marker type for the `identity` field
         pub struct identity(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `sigs` field
+        pub struct sigs(());
     }
 }
 
@@ -955,11 +955,11 @@ where
 impl<S: BosStr, St> ClaimBuilder<S, St>
 where
     St: claim_state::State,
-    St::Type: claim_state::IsSet,
     St::ClaimUri: claim_state::IsSet,
-    St::Sigs: claim_state::IsSet,
-    St::CreatedAt: claim_state::IsSet,
+    St::Type: claim_state::IsSet,
     St::Identity: claim_state::IsSet,
+    St::CreatedAt: claim_state::IsSet,
+    St::Sigs: claim_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Claim<S> {
diff --git a/crates/jacquard-api/src/dev_keytrace/server_public_key.rs b/crates/jacquard-api/src/dev_keytrace/server_public_key.rs
index af5ca651..e7d0eb2d 100644
--- a/crates/jacquard-api/src/dev_keytrace/server_public_key.rs
+++ b/crates/jacquard-api/src/dev_keytrace/server_public_key.rs
@@ -142,51 +142,51 @@ pub mod server_public_key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ValidUntil;
-        type PublicJwk;
         type ValidFrom;
+        type PublicJwk;
+        type ValidUntil;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ValidUntil = Unset;
-        type PublicJwk = Unset;
         type ValidFrom = Unset;
+        type PublicJwk = Unset;
+        type ValidUntil = Unset;
     }
-    ///State transition - sets the `valid_until` field to Set
-    pub struct SetValidUntil<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValidUntil<St> {}
-    impl<St: State> State for SetValidUntil<St> {
-        type ValidUntil = Set<members::valid_until>;
+    ///State transition - sets the `valid_from` field to Set
+    pub struct SetValidFrom<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValidFrom<St> {}
+    impl<St: State> State for SetValidFrom<St> {
+        type ValidFrom = Set<members::valid_from>;
         type PublicJwk = St::PublicJwk;
-        type ValidFrom = St::ValidFrom;
+        type ValidUntil = St::ValidUntil;
     }
     ///State transition - sets the `public_jwk` field to Set
     pub struct SetPublicJwk<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublicJwk<St> {}
     impl<St: State> State for SetPublicJwk<St> {
-        type ValidUntil = St::ValidUntil;
-        type PublicJwk = Set<members::public_jwk>;
         type ValidFrom = St::ValidFrom;
-    }
-    ///State transition - sets the `valid_from` field to Set
-    pub struct SetValidFrom<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValidFrom<St> {}
-    impl<St: State> State for SetValidFrom<St> {
+        type PublicJwk = Set<members::public_jwk>;
         type ValidUntil = St::ValidUntil;
+    }
+    ///State transition - sets the `valid_until` field to Set
+    pub struct SetValidUntil<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValidUntil<St> {}
+    impl<St: State> State for SetValidUntil<St> {
+        type ValidFrom = St::ValidFrom;
         type PublicJwk = St::PublicJwk;
-        type ValidFrom = Set<members::valid_from>;
+        type ValidUntil = Set<members::valid_until>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `valid_until` field
-        pub struct valid_until(());
-        ///Marker type for the `public_jwk` field
-        pub struct public_jwk(());
         ///Marker type for the `valid_from` field
         pub struct valid_from(());
+        ///Marker type for the `public_jwk` field
+        pub struct public_jwk(());
+        ///Marker type for the `valid_until` field
+        pub struct valid_until(());
     }
 }
 
@@ -288,9 +288,9 @@ where
 impl<S: BosStr, St> ServerPublicKeyBuilder<S, St>
 where
     St: server_public_key_state::State,
-    St::ValidUntil: server_public_key_state::IsSet,
-    St::PublicJwk: server_public_key_state::IsSet,
     St::ValidFrom: server_public_key_state::IsSet,
+    St::PublicJwk: server_public_key_state::IsSet,
+    St::ValidUntil: server_public_key_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ServerPublicKey<S> {
diff --git a/crates/jacquard-api/src/dev_keytrace/signature.rs b/crates/jacquard-api/src/dev_keytrace/signature.rs
index fe4000e0..90080571 100644
--- a/crates/jacquard-api/src/dev_keytrace/signature.rs
+++ b/crates/jacquard-api/src/dev_keytrace/signature.rs
@@ -87,84 +87,84 @@ pub mod signature_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Kid;
+        type SignedFields;
+        type Src;
         type Attestation;
         type SignedAt;
-        type Src;
-        type SignedFields;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Kid = Unset;
+        type SignedFields = Unset;
+        type Src = Unset;
         type Attestation = Unset;
         type SignedAt = Unset;
-        type Src = Unset;
-        type SignedFields = Unset;
     }
     ///State transition - sets the `kid` field to Set
     pub struct SetKid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKid<St> {}
     impl<St: State> State for SetKid<St> {
         type Kid = Set<members::kid>;
+        type SignedFields = St::SignedFields;
+        type Src = St::Src;
         type Attestation = St::Attestation;
         type SignedAt = St::SignedAt;
+    }
+    ///State transition - sets the `signed_fields` field to Set
+    pub struct SetSignedFields<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSignedFields<St> {}
+    impl<St: State> State for SetSignedFields<St> {
+        type Kid = St::Kid;
+        type SignedFields = Set<members::signed_fields>;
         type Src = St::Src;
+        type Attestation = St::Attestation;
+        type SignedAt = St::SignedAt;
+    }
+    ///State transition - sets the `src` field to Set
+    pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSrc<St> {}
+    impl<St: State> State for SetSrc<St> {
+        type Kid = St::Kid;
         type SignedFields = St::SignedFields;
+        type Src = Set<members::src>;
+        type Attestation = St::Attestation;
+        type SignedAt = St::SignedAt;
     }
     ///State transition - sets the `attestation` field to Set
     pub struct SetAttestation<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAttestation<St> {}
     impl<St: State> State for SetAttestation<St> {
         type Kid = St::Kid;
+        type SignedFields = St::SignedFields;
+        type Src = St::Src;
         type Attestation = Set<members::attestation>;
         type SignedAt = St::SignedAt;
-        type Src = St::Src;
-        type SignedFields = St::SignedFields;
     }
     ///State transition - sets the `signed_at` field to Set
     pub struct SetSignedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignedAt<St> {}
     impl<St: State> State for SetSignedAt<St> {
         type Kid = St::Kid;
-        type Attestation = St::Attestation;
-        type SignedAt = Set<members::signed_at>;
-        type Src = St::Src;
-        type SignedFields = St::SignedFields;
-    }
-    ///State transition - sets the `src` field to Set
-    pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSrc<St> {}
-    impl<St: State> State for SetSrc<St> {
-        type Kid = St::Kid;
-        type Attestation = St::Attestation;
-        type SignedAt = St::SignedAt;
-        type Src = Set<members::src>;
         type SignedFields = St::SignedFields;
-    }
-    ///State transition - sets the `signed_fields` field to Set
-    pub struct SetSignedFields<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSignedFields<St> {}
-    impl<St: State> State for SetSignedFields<St> {
-        type Kid = St::Kid;
-        type Attestation = St::Attestation;
-        type SignedAt = St::SignedAt;
         type Src = St::Src;
-        type SignedFields = Set<members::signed_fields>;
+        type Attestation = St::Attestation;
+        type SignedAt = Set<members::signed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `kid` field
         pub struct kid(());
+        ///Marker type for the `signed_fields` field
+        pub struct signed_fields(());
+        ///Marker type for the `src` field
+        pub struct src(());
         ///Marker type for the `attestation` field
         pub struct attestation(());
         ///Marker type for the `signed_at` field
         pub struct signed_at(());
-        ///Marker type for the `src` field
-        pub struct src(());
-        ///Marker type for the `signed_fields` field
-        pub struct signed_fields(());
     }
 }
 
@@ -326,10 +326,10 @@ impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
     St::Kid: signature_state::IsSet,
+    St::SignedFields: signature_state::IsSet,
+    St::Src: signature_state::IsSet,
     St::Attestation: signature_state::IsSet,
     St::SignedAt: signature_state::IsSet,
-    St::Src: signature_state::IsSet,
-    St::SignedFields: signature_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Signature<S> {
diff --git a/crates/jacquard-api/src/dev_keytrace/statement.rs b/crates/jacquard-api/src/dev_keytrace/statement.rs
index 1ac52532..0121f9cd 100644
--- a/crates/jacquard-api/src/dev_keytrace/statement.rs
+++ b/crates/jacquard-api/src/dev_keytrace/statement.rs
@@ -160,67 +160,67 @@ pub mod statement_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Sig;
         type KeyRef;
         type CreatedAt;
         type Content;
-        type Sig;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Sig = Unset;
         type KeyRef = Unset;
         type CreatedAt = Unset;
         type Content = Unset;
-        type Sig = Unset;
+    }
+    ///State transition - sets the `sig` field to Set
+    pub struct SetSig<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSig<St> {}
+    impl<St: State> State for SetSig<St> {
+        type Sig = Set<members::sig>;
+        type KeyRef = St::KeyRef;
+        type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
     }
     ///State transition - sets the `key_ref` field to Set
     pub struct SetKeyRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKeyRef<St> {}
     impl<St: State> State for SetKeyRef<St> {
+        type Sig = St::Sig;
         type KeyRef = Set<members::key_ref>;
         type CreatedAt = St::CreatedAt;
         type Content = St::Content;
-        type Sig = St::Sig;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Sig = St::Sig;
         type KeyRef = St::KeyRef;
         type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
-        type Sig = St::Sig;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type KeyRef = St::KeyRef;
-        type CreatedAt = St::CreatedAt;
-        type Content = Set<members::content>;
         type Sig = St::Sig;
-    }
-    ///State transition - sets the `sig` field to Set
-    pub struct SetSig<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSig<St> {}
-    impl<St: State> State for SetSig<St> {
         type KeyRef = St::KeyRef;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
-        type Sig = Set<members::sig>;
+        type Content = Set<members::content>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `sig` field
+        pub struct sig(());
         ///Marker type for the `key_ref` field
         pub struct key_ref(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
-        ///Marker type for the `sig` field
-        pub struct sig(());
     }
 }
 
@@ -361,10 +361,10 @@ impl<S: BosStr, St: statement_state::State> StatementBuilder<S, St> {
 impl<S: BosStr, St> StatementBuilder<S, St>
 where
     St: statement_state::State,
+    St::Sig: statement_state::IsSet,
     St::KeyRef: statement_state::IsSet,
     St::CreatedAt: statement_state::IsSet,
     St::Content: statement_state::IsSet,
-    St::Sig: statement_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Statement<S> {
diff --git a/crates/jacquard-api/src/dev_keytrace/user_public_key.rs b/crates/jacquard-api/src/dev_keytrace/user_public_key.rs
index 9f56e1e9..44df4bd8 100644
--- a/crates/jacquard-api/src/dev_keytrace/user_public_key.rs
+++ b/crates/jacquard-api/src/dev_keytrace/user_public_key.rs
@@ -276,49 +276,49 @@ pub mod user_public_key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type KeyType;
         type CreatedAt;
+        type KeyType;
         type PublicKeyArmored;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type KeyType = Unset;
         type CreatedAt = Unset;
+        type KeyType = Unset;
         type PublicKeyArmored = Unset;
     }
-    ///State transition - sets the `key_type` field to Set
-    pub struct SetKeyType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKeyType<St> {}
-    impl<St: State> State for SetKeyType<St> {
-        type KeyType = Set<members::key_type>;
-        type CreatedAt = St::CreatedAt;
-        type PublicKeyArmored = St::PublicKeyArmored;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type KeyType = St::KeyType;
         type CreatedAt = Set<members::created_at>;
+        type KeyType = St::KeyType;
+        type PublicKeyArmored = St::PublicKeyArmored;
+    }
+    ///State transition - sets the `key_type` field to Set
+    pub struct SetKeyType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKeyType<St> {}
+    impl<St: State> State for SetKeyType<St> {
+        type CreatedAt = St::CreatedAt;
+        type KeyType = Set<members::key_type>;
         type PublicKeyArmored = St::PublicKeyArmored;
     }
     ///State transition - sets the `public_key_armored` field to Set
     pub struct SetPublicKeyArmored<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublicKeyArmored<St> {}
     impl<St: State> State for SetPublicKeyArmored<St> {
-        type KeyType = St::KeyType;
         type CreatedAt = St::CreatedAt;
+        type KeyType = St::KeyType;
         type PublicKeyArmored = Set<members::public_key_armored>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `key_type` field
-        pub struct key_type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `key_type` field
+        pub struct key_type(());
         ///Marker type for the `public_key_armored` field
         pub struct public_key_armored(());
     }
@@ -483,8 +483,8 @@ impl<S: BosStr, St: user_public_key_state::State> UserPublicKeyBuilder<S, St> {
 impl<S: BosStr, St> UserPublicKeyBuilder<S, St>
 where
     St: user_public_key_state::State,
-    St::KeyType: user_public_key_state::IsSet,
     St::CreatedAt: user_public_key_state::IsSet,
+    St::KeyType: user_public_key_state::IsSet,
     St::PublicKeyArmored: user_public_key_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs
index cb2279f5..32f53c53 100644
--- a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs
+++ b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/board.rs
@@ -141,67 +141,67 @@ pub mod board_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Nsfw;
-        type Description;
         type CreatedAt;
         type Title;
+        type Nsfw;
+        type Description;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Nsfw = Unset;
-        type Description = Unset;
         type CreatedAt = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `nsfw` field to Set
-    pub struct SetNsfw<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNsfw<St> {}
-    impl<St: State> State for SetNsfw<St> {
-        type Nsfw = Set<members::nsfw>;
-        type Description = St::Description;
-        type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Nsfw = St::Nsfw;
-        type Description = Set<members::description>;
-        type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
+        type Nsfw = Unset;
+        type Description = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Nsfw = St::Nsfw;
-        type Description = St::Description;
         type CreatedAt = Set<members::created_at>;
         type Title = St::Title;
+        type Nsfw = St::Nsfw;
+        type Description = St::Description;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
+        type Title = Set<members::title>;
         type Nsfw = St::Nsfw;
         type Description = St::Description;
+    }
+    ///State transition - sets the `nsfw` field to Set
+    pub struct SetNsfw<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNsfw<St> {}
+    impl<St: State> State for SetNsfw<St> {
         type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
+        type Title = St::Title;
+        type Nsfw = Set<members::nsfw>;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
+        type Nsfw = St::Nsfw;
+        type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `nsfw` field
-        pub struct nsfw(());
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `nsfw` field
+        pub struct nsfw(());
+        ///Marker type for the `description` field
+        pub struct description(());
     }
 }
 
@@ -309,10 +309,10 @@ where
 impl<S: BosStr, St> BoardBuilder<S, St>
 where
     St: board_state::State,
-    St::Nsfw: board_state::IsSet,
-    St::Description: board_state::IsSet,
     St::CreatedAt: board_state::IsSet,
     St::Title: board_state::IsSet,
+    St::Nsfw: board_state::IsSet,
+    St::Description: board_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Board<S> {
diff --git a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs
index 92f2ab65..ea6a5190 100644
--- a/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs
+++ b/crates/jacquard-api/src/dev_ocbwoy3/blueboard/post.rs
@@ -168,51 +168,51 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
         type CreatedAt;
         type Parent;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
         type CreatedAt = Unset;
         type Parent = Unset;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
-        type CreatedAt = St::CreatedAt;
-        type Parent = St::Parent;
+        type Text = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
         type Parent = St::Parent;
+        type Text = St::Text;
     }
     ///State transition - sets the `parent` field to Set
     pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParent<St> {}
     impl<St: State> State for SetParent<St> {
-        type Text = St::Text;
         type CreatedAt = St::CreatedAt;
         type Parent = Set<members::parent>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type CreatedAt = St::CreatedAt;
+        type Parent = St::Parent;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `parent` field
         pub struct parent(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -314,9 +314,9 @@ where
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
-    St::Text: post_state::IsSet,
     St::CreatedAt: post_state::IsSet,
     St::Parent: post_state::IsSet,
+    St::Text: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs b/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs
index 2dd30735..70865c5e 100644
--- a/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs
+++ b/crates/jacquard-api/src/dev_regnault/webfishing/savefile.rs
@@ -112,37 +112,37 @@ pub mod savefile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Uri;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Uri = St::Uri;
+        type Name = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Name = St::Name;
         type Uri = Set<members::uri>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Uri = St::Uri;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -212,8 +212,8 @@ where
 impl<S: BosStr, St> SavefileBuilder<S, St>
 where
     St: savefile_state::State,
-    St::Name: savefile_state::IsSet,
     St::Uri: savefile_state::IsSet,
+    St::Name: savefile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Savefile<S> {
diff --git a/crates/jacquard-api/src/dev_sensorthings/datastream.rs b/crates/jacquard-api/src/dev_sensorthings/datastream.rs
index ff69edbd..4b91df37 100644
--- a/crates/jacquard-api/src/dev_sensorthings/datastream.rs
+++ b/crates/jacquard-api/src/dev_sensorthings/datastream.rs
@@ -215,127 +215,127 @@ pub mod datastream_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type UnitOfMeasurement;
+        type ObservedProperty;
         type Name;
+        type ObservationType;
+        type CreatedAt;
         type Thing;
         type Sensor;
-        type ObservedProperty;
-        type UnitOfMeasurement;
-        type CreatedAt;
-        type ObservationType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type UnitOfMeasurement = Unset;
+        type ObservedProperty = Unset;
         type Name = Unset;
+        type ObservationType = Unset;
+        type CreatedAt = Unset;
         type Thing = Unset;
         type Sensor = Unset;
-        type ObservedProperty = Unset;
-        type UnitOfMeasurement = Unset;
-        type CreatedAt = Unset;
-        type ObservationType = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Thing = St::Thing;
-        type Sensor = St::Sensor;
+    ///State transition - sets the `unit_of_measurement` field to Set
+    pub struct SetUnitOfMeasurement<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUnitOfMeasurement<St> {}
+    impl<St: State> State for SetUnitOfMeasurement<St> {
+        type UnitOfMeasurement = Set<members::unit_of_measurement>;
         type ObservedProperty = St::ObservedProperty;
-        type UnitOfMeasurement = St::UnitOfMeasurement;
-        type CreatedAt = St::CreatedAt;
-        type ObservationType = St::ObservationType;
-    }
-    ///State transition - sets the `thing` field to Set
-    pub struct SetThing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetThing<St> {}
-    impl<St: State> State for SetThing<St> {
         type Name = St::Name;
-        type Thing = Set<members::thing>;
-        type Sensor = St::Sensor;
-        type ObservedProperty = St::ObservedProperty;
-        type UnitOfMeasurement = St::UnitOfMeasurement;
-        type CreatedAt = St::CreatedAt;
         type ObservationType = St::ObservationType;
-    }
-    ///State transition - sets the `sensor` field to Set
-    pub struct SetSensor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSensor<St> {}
-    impl<St: State> State for SetSensor<St> {
-        type Name = St::Name;
-        type Thing = St::Thing;
-        type Sensor = Set<members::sensor>;
-        type ObservedProperty = St::ObservedProperty;
-        type UnitOfMeasurement = St::UnitOfMeasurement;
         type CreatedAt = St::CreatedAt;
-        type ObservationType = St::ObservationType;
+        type Thing = St::Thing;
+        type Sensor = St::Sensor;
     }
     ///State transition - sets the `observed_property` field to Set
     pub struct SetObservedProperty<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetObservedProperty<St> {}
     impl<St: State> State for SetObservedProperty<St> {
+        type UnitOfMeasurement = St::UnitOfMeasurement;
+        type ObservedProperty = Set<members::observed_property>;
         type Name = St::Name;
+        type ObservationType = St::ObservationType;
+        type CreatedAt = St::CreatedAt;
         type Thing = St::Thing;
         type Sensor = St::Sensor;
-        type ObservedProperty = Set<members::observed_property>;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
         type UnitOfMeasurement = St::UnitOfMeasurement;
-        type CreatedAt = St::CreatedAt;
+        type ObservedProperty = St::ObservedProperty;
+        type Name = Set<members::name>;
         type ObservationType = St::ObservationType;
-    }
-    ///State transition - sets the `unit_of_measurement` field to Set
-    pub struct SetUnitOfMeasurement<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUnitOfMeasurement<St> {}
-    impl<St: State> State for SetUnitOfMeasurement<St> {
-        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
         type Thing = St::Thing;
         type Sensor = St::Sensor;
+    }
+    ///State transition - sets the `observation_type` field to Set
+    pub struct SetObservationType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObservationType<St> {}
+    impl<St: State> State for SetObservationType<St> {
+        type UnitOfMeasurement = St::UnitOfMeasurement;
         type ObservedProperty = St::ObservedProperty;
-        type UnitOfMeasurement = Set<members::unit_of_measurement>;
+        type Name = St::Name;
+        type ObservationType = Set<members::observation_type>;
         type CreatedAt = St::CreatedAt;
-        type ObservationType = St::ObservationType;
+        type Thing = St::Thing;
+        type Sensor = St::Sensor;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type UnitOfMeasurement = St::UnitOfMeasurement;
+        type ObservedProperty = St::ObservedProperty;
         type Name = St::Name;
+        type ObservationType = St::ObservationType;
+        type CreatedAt = Set<members::created_at>;
         type Thing = St::Thing;
         type Sensor = St::Sensor;
-        type ObservedProperty = St::ObservedProperty;
-        type UnitOfMeasurement = St::UnitOfMeasurement;
-        type CreatedAt = Set<members::created_at>;
-        type ObservationType = St::ObservationType;
     }
-    ///State transition - sets the `observation_type` field to Set
-    pub struct SetObservationType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObservationType<St> {}
-    impl<St: State> State for SetObservationType<St> {
+    ///State transition - sets the `thing` field to Set
+    pub struct SetThing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetThing<St> {}
+    impl<St: State> State for SetThing<St> {
+        type UnitOfMeasurement = St::UnitOfMeasurement;
+        type ObservedProperty = St::ObservedProperty;
         type Name = St::Name;
-        type Thing = St::Thing;
+        type ObservationType = St::ObservationType;
+        type CreatedAt = St::CreatedAt;
+        type Thing = Set<members::thing>;
         type Sensor = St::Sensor;
-        type ObservedProperty = St::ObservedProperty;
+    }
+    ///State transition - sets the `sensor` field to Set
+    pub struct SetSensor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSensor<St> {}
+    impl<St: State> State for SetSensor<St> {
         type UnitOfMeasurement = St::UnitOfMeasurement;
+        type ObservedProperty = St::ObservedProperty;
+        type Name = St::Name;
+        type ObservationType = St::ObservationType;
         type CreatedAt = St::CreatedAt;
-        type ObservationType = Set<members::observation_type>;
+        type Thing = St::Thing;
+        type Sensor = Set<members::sensor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `unit_of_measurement` field
+        pub struct unit_of_measurement(());
+        ///Marker type for the `observed_property` field
+        pub struct observed_property(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `observation_type` field
+        pub struct observation_type(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `thing` field
         pub struct thing(());
         ///Marker type for the `sensor` field
         pub struct sensor(());
-        ///Marker type for the `observed_property` field
-        pub struct observed_property(());
-        ///Marker type for the `unit_of_measurement` field
-        pub struct unit_of_measurement(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `observation_type` field
-        pub struct observation_type(());
     }
 }
 
@@ -564,13 +564,13 @@ impl<S: BosStr, St: datastream_state::State> DatastreamBuilder<S, St> {
 impl<S: BosStr, St> DatastreamBuilder<S, St>
 where
     St: datastream_state::State,
+    St::UnitOfMeasurement: datastream_state::IsSet,
+    St::ObservedProperty: datastream_state::IsSet,
     St::Name: datastream_state::IsSet,
+    St::ObservationType: datastream_state::IsSet,
+    St::CreatedAt: datastream_state::IsSet,
     St::Thing: datastream_state::IsSet,
     St::Sensor: datastream_state::IsSet,
-    St::ObservedProperty: datastream_state::IsSet,
-    St::UnitOfMeasurement: datastream_state::IsSet,
-    St::CreatedAt: datastream_state::IsSet,
-    St::ObservationType: datastream_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Datastream<S> {
diff --git a/crates/jacquard-api/src/dev_sensorthings/feature_of_interest.rs b/crates/jacquard-api/src/dev_sensorthings/feature_of_interest.rs
index 9ebc61f2..55958fbd 100644
--- a/crates/jacquard-api/src/dev_sensorthings/feature_of_interest.rs
+++ b/crates/jacquard-api/src/dev_sensorthings/feature_of_interest.rs
@@ -150,67 +150,67 @@ pub mod feature_of_interest_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type EncodingType;
-        type Feature;
         type Name;
         type CreatedAt;
+        type EncodingType;
+        type Feature;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type EncodingType = Unset;
-        type Feature = Unset;
         type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `encoding_type` field to Set
-    pub struct SetEncodingType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEncodingType<St> {}
-    impl<St: State> State for SetEncodingType<St> {
-        type EncodingType = Set<members::encoding_type>;
-        type Feature = St::Feature;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `feature` field to Set
-    pub struct SetFeature<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFeature<St> {}
-    impl<St: State> State for SetFeature<St> {
-        type EncodingType = St::EncodingType;
-        type Feature = Set<members::feature>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
+        type EncodingType = Unset;
+        type Feature = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type EncodingType = St::EncodingType;
-        type Feature = St::Feature;
         type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
+        type EncodingType = St::EncodingType;
+        type Feature = St::Feature;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
         type EncodingType = St::EncodingType;
         type Feature = St::Feature;
+    }
+    ///State transition - sets the `encoding_type` field to Set
+    pub struct SetEncodingType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEncodingType<St> {}
+    impl<St: State> State for SetEncodingType<St> {
         type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
+        type CreatedAt = St::CreatedAt;
+        type EncodingType = Set<members::encoding_type>;
+        type Feature = St::Feature;
+    }
+    ///State transition - sets the `feature` field to Set
+    pub struct SetFeature<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFeature<St> {}
+    impl<St: State> State for SetFeature<St> {
+        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
+        type EncodingType = St::EncodingType;
+        type Feature = Set<members::feature>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `encoding_type` field
-        pub struct encoding_type(());
-        ///Marker type for the `feature` field
-        pub struct feature(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `encoding_type` field
+        pub struct encoding_type(());
+        ///Marker type for the `feature` field
+        pub struct feature(());
     }
 }
 
@@ -331,10 +331,10 @@ where
 impl<S: BosStr, St> FeatureOfInterestBuilder<S, St>
 where
     St: feature_of_interest_state::State,
-    St::EncodingType: feature_of_interest_state::IsSet,
-    St::Feature: feature_of_interest_state::IsSet,
     St::Name: feature_of_interest_state::IsSet,
     St::CreatedAt: feature_of_interest_state::IsSet,
+    St::EncodingType: feature_of_interest_state::IsSet,
+    St::Feature: feature_of_interest_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FeatureOfInterest<S> {
diff --git a/crates/jacquard-api/src/dev_sensorthings/multi_observation.rs b/crates/jacquard-api/src/dev_sensorthings/multi_observation.rs
index e93cacc2..ee8318e0 100644
--- a/crates/jacquard-api/src/dev_sensorthings/multi_observation.rs
+++ b/crates/jacquard-api/src/dev_sensorthings/multi_observation.rs
@@ -394,67 +394,67 @@ pub mod multi_observation_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Thing;
-        type Sensor;
         type PhenomenonTime;
         type Entries;
+        type Thing;
+        type Sensor;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Thing = Unset;
-        type Sensor = Unset;
         type PhenomenonTime = Unset;
         type Entries = Unset;
-    }
-    ///State transition - sets the `thing` field to Set
-    pub struct SetThing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetThing<St> {}
-    impl<St: State> State for SetThing<St> {
-        type Thing = Set<members::thing>;
-        type Sensor = St::Sensor;
-        type PhenomenonTime = St::PhenomenonTime;
-        type Entries = St::Entries;
-    }
-    ///State transition - sets the `sensor` field to Set
-    pub struct SetSensor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSensor<St> {}
-    impl<St: State> State for SetSensor<St> {
-        type Thing = St::Thing;
-        type Sensor = Set<members::sensor>;
-        type PhenomenonTime = St::PhenomenonTime;
-        type Entries = St::Entries;
+        type Thing = Unset;
+        type Sensor = Unset;
     }
     ///State transition - sets the `phenomenon_time` field to Set
     pub struct SetPhenomenonTime<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPhenomenonTime<St> {}
     impl<St: State> State for SetPhenomenonTime<St> {
-        type Thing = St::Thing;
-        type Sensor = St::Sensor;
         type PhenomenonTime = Set<members::phenomenon_time>;
         type Entries = St::Entries;
+        type Thing = St::Thing;
+        type Sensor = St::Sensor;
     }
     ///State transition - sets the `entries` field to Set
     pub struct SetEntries<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEntries<St> {}
     impl<St: State> State for SetEntries<St> {
+        type PhenomenonTime = St::PhenomenonTime;
+        type Entries = Set<members::entries>;
         type Thing = St::Thing;
         type Sensor = St::Sensor;
+    }
+    ///State transition - sets the `thing` field to Set
+    pub struct SetThing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetThing<St> {}
+    impl<St: State> State for SetThing<St> {
         type PhenomenonTime = St::PhenomenonTime;
-        type Entries = Set<members::entries>;
+        type Entries = St::Entries;
+        type Thing = Set<members::thing>;
+        type Sensor = St::Sensor;
+    }
+    ///State transition - sets the `sensor` field to Set
+    pub struct SetSensor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSensor<St> {}
+    impl<St: State> State for SetSensor<St> {
+        type PhenomenonTime = St::PhenomenonTime;
+        type Entries = St::Entries;
+        type Thing = St::Thing;
+        type Sensor = Set<members::sensor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `thing` field
-        pub struct thing(());
-        ///Marker type for the `sensor` field
-        pub struct sensor(());
         ///Marker type for the `phenomenon_time` field
         pub struct phenomenon_time(());
         ///Marker type for the `entries` field
         pub struct entries(());
+        ///Marker type for the `thing` field
+        pub struct thing(());
+        ///Marker type for the `sensor` field
+        pub struct sensor(());
     }
 }
 
@@ -629,10 +629,10 @@ where
 impl<S: BosStr, St> MultiObservationBuilder<S, St>
 where
     St: multi_observation_state::State,
-    St::Thing: multi_observation_state::IsSet,
-    St::Sensor: multi_observation_state::IsSet,
     St::PhenomenonTime: multi_observation_state::IsSet,
     St::Entries: multi_observation_state::IsSet,
+    St::Thing: multi_observation_state::IsSet,
+    St::Sensor: multi_observation_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MultiObservation<S> {
@@ -896,50 +896,50 @@ pub mod multi_observation_entry_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type UnitOfMeasurement;
-        type ObservedProperty;
         type Result;
+        type ObservedProperty;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type UnitOfMeasurement = Unset;
-        type ObservedProperty = Unset;
         type Result = Unset;
+        type ObservedProperty = Unset;
     }
     ///State transition - sets the `unit_of_measurement` field to Set
     pub struct SetUnitOfMeasurement<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUnitOfMeasurement<St> {}
     impl<St: State> State for SetUnitOfMeasurement<St> {
         type UnitOfMeasurement = Set<members::unit_of_measurement>;
-        type ObservedProperty = St::ObservedProperty;
-        type Result = St::Result;
-    }
-    ///State transition - sets the `observed_property` field to Set
-    pub struct SetObservedProperty<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObservedProperty<St> {}
-    impl<St: State> State for SetObservedProperty<St> {
-        type UnitOfMeasurement = St::UnitOfMeasurement;
-        type ObservedProperty = Set<members::observed_property>;
         type Result = St::Result;
+        type ObservedProperty = St::ObservedProperty;
     }
     ///State transition - sets the `result` field to Set
     pub struct SetResult<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResult<St> {}
     impl<St: State> State for SetResult<St> {
         type UnitOfMeasurement = St::UnitOfMeasurement;
-        type ObservedProperty = St::ObservedProperty;
         type Result = Set<members::result>;
+        type ObservedProperty = St::ObservedProperty;
+    }
+    ///State transition - sets the `observed_property` field to Set
+    pub struct SetObservedProperty<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObservedProperty<St> {}
+    impl<St: State> State for SetObservedProperty<St> {
+        type UnitOfMeasurement = St::UnitOfMeasurement;
+        type Result = St::Result;
+        type ObservedProperty = Set<members::observed_property>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `unit_of_measurement` field
         pub struct unit_of_measurement(());
-        ///Marker type for the `observed_property` field
-        pub struct observed_property(());
         ///Marker type for the `result` field
         pub struct result(());
+        ///Marker type for the `observed_property` field
+        pub struct observed_property(());
     }
 }
 
@@ -1085,8 +1085,8 @@ impl<S: BosStr, St> MultiObservationEntryBuilder<S, St>
 where
     St: multi_observation_entry_state::State,
     St::UnitOfMeasurement: multi_observation_entry_state::IsSet,
-    St::ObservedProperty: multi_observation_entry_state::IsSet,
     St::Result: multi_observation_entry_state::IsSet,
+    St::ObservedProperty: multi_observation_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MultiObservationEntry<S> {
diff --git a/crates/jacquard-api/src/dev_sensorthings/observation_batch.rs b/crates/jacquard-api/src/dev_sensorthings/observation_batch.rs
index 32114055..10b894d7 100644
--- a/crates/jacquard-api/src/dev_sensorthings/observation_batch.rs
+++ b/crates/jacquard-api/src/dev_sensorthings/observation_batch.rs
@@ -517,67 +517,67 @@ pub mod observation_batch_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Datastream;
+        type WindowEnd;
         type Observations;
         type WindowStart;
-        type WindowEnd;
-        type Datastream;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Datastream = Unset;
+        type WindowEnd = Unset;
         type Observations = Unset;
         type WindowStart = Unset;
-        type WindowEnd = Unset;
-        type Datastream = Unset;
+    }
+    ///State transition - sets the `datastream` field to Set
+    pub struct SetDatastream<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDatastream<St> {}
+    impl<St: State> State for SetDatastream<St> {
+        type Datastream = Set<members::datastream>;
+        type WindowEnd = St::WindowEnd;
+        type Observations = St::Observations;
+        type WindowStart = St::WindowStart;
+    }
+    ///State transition - sets the `window_end` field to Set
+    pub struct SetWindowEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWindowEnd<St> {}
+    impl<St: State> State for SetWindowEnd<St> {
+        type Datastream = St::Datastream;
+        type WindowEnd = Set<members::window_end>;
+        type Observations = St::Observations;
+        type WindowStart = St::WindowStart;
     }
     ///State transition - sets the `observations` field to Set
     pub struct SetObservations<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetObservations<St> {}
     impl<St: State> State for SetObservations<St> {
+        type Datastream = St::Datastream;
+        type WindowEnd = St::WindowEnd;
         type Observations = Set<members::observations>;
         type WindowStart = St::WindowStart;
-        type WindowEnd = St::WindowEnd;
-        type Datastream = St::Datastream;
     }
     ///State transition - sets the `window_start` field to Set
     pub struct SetWindowStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWindowStart<St> {}
     impl<St: State> State for SetWindowStart<St> {
-        type Observations = St::Observations;
-        type WindowStart = Set<members::window_start>;
-        type WindowEnd = St::WindowEnd;
-        type Datastream = St::Datastream;
-    }
-    ///State transition - sets the `window_end` field to Set
-    pub struct SetWindowEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWindowEnd<St> {}
-    impl<St: State> State for SetWindowEnd<St> {
-        type Observations = St::Observations;
-        type WindowStart = St::WindowStart;
-        type WindowEnd = Set<members::window_end>;
         type Datastream = St::Datastream;
-    }
-    ///State transition - sets the `datastream` field to Set
-    pub struct SetDatastream<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDatastream<St> {}
-    impl<St: State> State for SetDatastream<St> {
-        type Observations = St::Observations;
-        type WindowStart = St::WindowStart;
         type WindowEnd = St::WindowEnd;
-        type Datastream = Set<members::datastream>;
+        type Observations = St::Observations;
+        type WindowStart = Set<members::window_start>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `datastream` field
+        pub struct datastream(());
+        ///Marker type for the `window_end` field
+        pub struct window_end(());
         ///Marker type for the `observations` field
         pub struct observations(());
         ///Marker type for the `window_start` field
         pub struct window_start(());
-        ///Marker type for the `window_end` field
-        pub struct window_end(());
-        ///Marker type for the `datastream` field
-        pub struct datastream(());
     }
 }
 
@@ -690,10 +690,10 @@ where
 impl<S: BosStr, St> ObservationBatchBuilder<S, St>
 where
     St: observation_batch_state::State,
+    St::Datastream: observation_batch_state::IsSet,
+    St::WindowEnd: observation_batch_state::IsSet,
     St::Observations: observation_batch_state::IsSet,
     St::WindowStart: observation_batch_state::IsSet,
-    St::WindowEnd: observation_batch_state::IsSet,
-    St::Datastream: observation_batch_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ObservationBatch<S> {
diff --git a/crates/jacquard-api/src/dev_sensorthings/sensor.rs b/crates/jacquard-api/src/dev_sensorthings/sensor.rs
index b62e8327..82b58c8f 100644
--- a/crates/jacquard-api/src/dev_sensorthings/sensor.rs
+++ b/crates/jacquard-api/src/dev_sensorthings/sensor.rs
@@ -161,51 +161,51 @@ pub mod sensor_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type EncodingType;
         type CreatedAt;
+        type EncodingType;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type EncodingType = Unset;
         type CreatedAt = Unset;
+        type EncodingType = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type EncodingType = St::EncodingType;
-        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
     }
     ///State transition - sets the `encoding_type` field to Set
     pub struct SetEncodingType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEncodingType<St> {}
     impl<St: State> State for SetEncodingType<St> {
-        type Name = St::Name;
-        type EncodingType = Set<members::encoding_type>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type EncodingType = Set<members::encoding_type>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
         type EncodingType = St::EncodingType;
-        type CreatedAt = Set<members::created_at>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `encoding_type` field
-        pub struct encoding_type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `encoding_type` field
+        pub struct encoding_type(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -320,9 +320,9 @@ where
 impl<S: BosStr, St> SensorBuilder<S, St>
 where
     St: sensor_state::State,
-    St::Name: sensor_state::IsSet,
-    St::EncodingType: sensor_state::IsSet,
     St::CreatedAt: sensor_state::IsSet,
+    St::EncodingType: sensor_state::IsSet,
+    St::Name: sensor_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Sensor<S> {
diff --git a/crates/jacquard-api/src/dev_tsunagite/chart.rs b/crates/jacquard-api/src/dev_tsunagite/chart.rs
index 19713e27..e3a1f5ed 100644
--- a/crates/jacquard-api/src/dev_tsunagite/chart.rs
+++ b/crates/jacquard-api/src/dev_tsunagite/chart.rs
@@ -188,67 +188,67 @@ pub mod chart_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Rating;
         type Game;
-        type Difficulty;
         type Song;
-        type Rating;
+        type Difficulty;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Rating = Unset;
         type Game = Unset;
-        type Difficulty = Unset;
         type Song = Unset;
-        type Rating = Unset;
+        type Difficulty = Unset;
+    }
+    ///State transition - sets the `rating` field to Set
+    pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRating<St> {}
+    impl<St: State> State for SetRating<St> {
+        type Rating = Set<members::rating>;
+        type Game = St::Game;
+        type Song = St::Song;
+        type Difficulty = St::Difficulty;
     }
     ///State transition - sets the `game` field to Set
     pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGame<St> {}
     impl<St: State> State for SetGame<St> {
-        type Game = Set<members::game>;
-        type Difficulty = St::Difficulty;
-        type Song = St::Song;
         type Rating = St::Rating;
-    }
-    ///State transition - sets the `difficulty` field to Set
-    pub struct SetDifficulty<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDifficulty<St> {}
-    impl<St: State> State for SetDifficulty<St> {
-        type Game = St::Game;
-        type Difficulty = Set<members::difficulty>;
+        type Game = Set<members::game>;
         type Song = St::Song;
-        type Rating = St::Rating;
+        type Difficulty = St::Difficulty;
     }
     ///State transition - sets the `song` field to Set
     pub struct SetSong<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSong<St> {}
     impl<St: State> State for SetSong<St> {
+        type Rating = St::Rating;
         type Game = St::Game;
-        type Difficulty = St::Difficulty;
         type Song = Set<members::song>;
-        type Rating = St::Rating;
+        type Difficulty = St::Difficulty;
     }
-    ///State transition - sets the `rating` field to Set
-    pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRating<St> {}
-    impl<St: State> State for SetRating<St> {
+    ///State transition - sets the `difficulty` field to Set
+    pub struct SetDifficulty<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDifficulty<St> {}
+    impl<St: State> State for SetDifficulty<St> {
+        type Rating = St::Rating;
         type Game = St::Game;
-        type Difficulty = St::Difficulty;
         type Song = St::Song;
-        type Rating = Set<members::rating>;
+        type Difficulty = Set<members::difficulty>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `rating` field
+        pub struct rating(());
         ///Marker type for the `game` field
         pub struct game(());
-        ///Marker type for the `difficulty` field
-        pub struct difficulty(());
         ///Marker type for the `song` field
         pub struct song(());
-        ///Marker type for the `rating` field
-        pub struct rating(());
+        ///Marker type for the `difficulty` field
+        pub struct difficulty(());
     }
 }
 
@@ -403,10 +403,10 @@ where
 impl<S: BosStr, St> ChartBuilder<S, St>
 where
     St: chart_state::State,
+    St::Rating: chart_state::IsSet,
     St::Game: chart_state::IsSet,
-    St::Difficulty: chart_state::IsSet,
     St::Song: chart_state::IsSet,
-    St::Rating: chart_state::IsSet,
+    St::Difficulty: chart_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Chart<S> {
diff --git a/crates/jacquard-api/src/dev_tsunagite/game.rs b/crates/jacquard-api/src/dev_tsunagite/game.rs
index 894fe481..0323d795 100644
--- a/crates/jacquard-api/src/dev_tsunagite/game.rs
+++ b/crates/jacquard-api/src/dev_tsunagite/game.rs
@@ -402,51 +402,51 @@ pub mod enum_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Id;
         type Values;
         type Name;
-        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Id = Unset;
         type Values = Unset;
         type Name = Unset;
-        type Id = Unset;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
+        type Values = St::Values;
+        type Name = St::Name;
     }
     ///State transition - sets the `values` field to Set
     pub struct SetValues<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValues<St> {}
     impl<St: State> State for SetValues<St> {
+        type Id = St::Id;
         type Values = Set<members::values>;
         type Name = St::Name;
-        type Id = St::Id;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Values = St::Values;
-        type Name = Set<members::name>;
         type Id = St::Id;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
         type Values = St::Values;
-        type Name = St::Name;
-        type Id = Set<members::id>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `values` field
         pub struct values(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `id` field
-        pub struct id(());
     }
 }
 
@@ -535,9 +535,9 @@ where
 impl<S: BosStr, St> EnumBuilder<S, St>
 where
     St: enum_state::State,
+    St::Id: enum_state::IsSet,
     St::Values: enum_state::IsSet,
     St::Name: enum_state::IsSet,
-    St::Id: enum_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Enum<S> {
@@ -902,8 +902,8 @@ pub mod game_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Judgments;
+        type Name;
         type ScoreComponents;
         type DefaultComponent;
     }
@@ -911,26 +911,26 @@ pub mod game_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Judgments = Unset;
+        type Name = Unset;
         type ScoreComponents = Unset;
         type DefaultComponent = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Judgments = St::Judgments;
-        type ScoreComponents = St::ScoreComponents;
-        type DefaultComponent = St::DefaultComponent;
-    }
     ///State transition - sets the `judgments` field to Set
     pub struct SetJudgments<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetJudgments<St> {}
     impl<St: State> State for SetJudgments<St> {
-        type Name = St::Name;
         type Judgments = Set<members::judgments>;
+        type Name = St::Name;
+        type ScoreComponents = St::ScoreComponents;
+        type DefaultComponent = St::DefaultComponent;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Judgments = St::Judgments;
+        type Name = Set<members::name>;
         type ScoreComponents = St::ScoreComponents;
         type DefaultComponent = St::DefaultComponent;
     }
@@ -938,8 +938,8 @@ pub mod game_state {
     pub struct SetScoreComponents<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScoreComponents<St> {}
     impl<St: State> State for SetScoreComponents<St> {
-        type Name = St::Name;
         type Judgments = St::Judgments;
+        type Name = St::Name;
         type ScoreComponents = Set<members::score_components>;
         type DefaultComponent = St::DefaultComponent;
     }
@@ -947,18 +947,18 @@ pub mod game_state {
     pub struct SetDefaultComponent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDefaultComponent<St> {}
     impl<St: State> State for SetDefaultComponent<St> {
-        type Name = St::Name;
         type Judgments = St::Judgments;
+        type Name = St::Name;
         type ScoreComponents = St::ScoreComponents;
         type DefaultComponent = Set<members::default_component>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `judgments` field
         pub struct judgments(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `score_components` field
         pub struct score_components(());
         ///Marker type for the `default_component` field
@@ -1117,8 +1117,8 @@ where
 impl<S: BosStr, St> GameBuilder<S, St>
 where
     St: game_state::State,
-    St::Name: game_state::IsSet,
     St::Judgments: game_state::IsSet,
+    St::Name: game_state::IsSet,
     St::ScoreComponents: game_state::IsSet,
     St::DefaultComponent: game_state::IsSet,
 {
@@ -1168,67 +1168,67 @@ pub mod percentage_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Maximum;
         type Id;
-        type Name;
         type Precision;
-        type Maximum;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Maximum = Unset;
         type Id = Unset;
-        type Name = Unset;
         type Precision = Unset;
-        type Maximum = Unset;
+        type Name = Unset;
+    }
+    ///State transition - sets the `maximum` field to Set
+    pub struct SetMaximum<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMaximum<St> {}
+    impl<St: State> State for SetMaximum<St> {
+        type Maximum = Set<members::maximum>;
+        type Id = St::Id;
+        type Precision = St::Precision;
+        type Name = St::Name;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
-        type Name = St::Name;
-        type Precision = St::Precision;
         type Maximum = St::Maximum;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Id = St::Id;
-        type Name = Set<members::name>;
+        type Id = Set<members::id>;
         type Precision = St::Precision;
-        type Maximum = St::Maximum;
+        type Name = St::Name;
     }
     ///State transition - sets the `precision` field to Set
     pub struct SetPrecision<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPrecision<St> {}
     impl<St: State> State for SetPrecision<St> {
+        type Maximum = St::Maximum;
         type Id = St::Id;
-        type Name = St::Name;
         type Precision = Set<members::precision>;
-        type Maximum = St::Maximum;
+        type Name = St::Name;
     }
-    ///State transition - sets the `maximum` field to Set
-    pub struct SetMaximum<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMaximum<St> {}
-    impl<St: State> State for SetMaximum<St> {
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Maximum = St::Maximum;
         type Id = St::Id;
-        type Name = St::Name;
         type Precision = St::Precision;
-        type Maximum = Set<members::maximum>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `maximum` field
+        pub struct maximum(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `precision` field
         pub struct precision(());
-        ///Marker type for the `maximum` field
-        pub struct maximum(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -1336,10 +1336,10 @@ where
 impl<S: BosStr, St> PercentageBuilder<S, St>
 where
     St: percentage_state::State,
+    St::Maximum: percentage_state::IsSet,
     St::Id: percentage_state::IsSet,
-    St::Name: percentage_state::IsSet,
     St::Precision: percentage_state::IsSet,
-    St::Maximum: percentage_state::IsSet,
+    St::Name: percentage_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Percentage<S> {
diff --git a/crates/jacquard-api/src/dev_tsunagite/song.rs b/crates/jacquard-api/src/dev_tsunagite/song.rs
index 4ae57221..f2d1c0d3 100644
--- a/crates/jacquard-api/src/dev_tsunagite/song.rs
+++ b/crates/jacquard-api/src/dev_tsunagite/song.rs
@@ -178,51 +178,51 @@ pub mod song_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Composer;
         type Game;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Composer = Unset;
         type Game = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Composer = St::Composer;
-        type Game = St::Game;
+        type Title = Unset;
     }
     ///State transition - sets the `composer` field to Set
     pub struct SetComposer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetComposer<St> {}
     impl<St: State> State for SetComposer<St> {
-        type Title = St::Title;
         type Composer = Set<members::composer>;
         type Game = St::Game;
+        type Title = St::Title;
     }
     ///State transition - sets the `game` field to Set
     pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGame<St> {}
     impl<St: State> State for SetGame<St> {
-        type Title = St::Title;
         type Composer = St::Composer;
         type Game = Set<members::game>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Composer = St::Composer;
+        type Game = St::Game;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `composer` field
         pub struct composer(());
         ///Marker type for the `game` field
         pub struct game(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -385,9 +385,9 @@ where
 impl<S: BosStr, St> SongBuilder<S, St>
 where
     St: song_state::State,
-    St::Title: song_state::IsSet,
     St::Composer: song_state::IsSet,
     St::Game: song_state::IsSet,
+    St::Title: song_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Song<S> {
diff --git a/crates/jacquard-api/src/dev_tsunagite/types.rs b/crates/jacquard-api/src/dev_tsunagite/types.rs
index bbecc2a1..77d1326e 100644
--- a/crates/jacquard-api/src/dev_tsunagite/types.rs
+++ b/crates/jacquard-api/src/dev_tsunagite/types.rs
@@ -116,51 +116,51 @@ pub mod indexable_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Id;
         type Name;
         type Index;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Id = Unset;
         type Name = Unset;
         type Index = Unset;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
-        type Name = St::Name;
-        type Index = St::Index;
+        type Id = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Id = St::Id;
         type Name = Set<members::name>;
         type Index = St::Index;
+        type Id = St::Id;
     }
     ///State transition - sets the `index` field to Set
     pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndex<St> {}
     impl<St: State> State for SetIndex<St> {
-        type Id = St::Id;
         type Name = St::Name;
         type Index = Set<members::index>;
+        type Id = St::Id;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Name = St::Name;
+        type Index = St::Index;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `index` field
         pub struct index(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> IndexableBuilder<S, St>
 where
     St: indexable_state::State,
-    St::Id: indexable_state::IsSet,
     St::Name: indexable_state::IsSet,
     St::Index: indexable_state::IsSet,
+    St::Id: indexable_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Indexable<S> {
diff --git a/crates/jacquard-api/src/dev_vielle/guestbook/entry.rs b/crates/jacquard-api/src/dev_vielle/guestbook/entry.rs
index 45f29af1..c65276a4 100644
--- a/crates/jacquard-api/src/dev_vielle/guestbook/entry.rs
+++ b/crates/jacquard-api/src/dev_vielle/guestbook/entry.rs
@@ -111,37 +111,37 @@ pub mod entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Contents;
         type Book;
+        type Contents;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Contents = Unset;
         type Book = Unset;
-    }
-    ///State transition - sets the `contents` field to Set
-    pub struct SetContents<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContents<St> {}
-    impl<St: State> State for SetContents<St> {
-        type Contents = Set<members::contents>;
-        type Book = St::Book;
+        type Contents = Unset;
     }
     ///State transition - sets the `book` field to Set
     pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBook<St> {}
     impl<St: State> State for SetBook<St> {
-        type Contents = St::Contents;
         type Book = Set<members::book>;
+        type Contents = St::Contents;
+    }
+    ///State transition - sets the `contents` field to Set
+    pub struct SetContents<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContents<St> {}
+    impl<St: State> State for SetContents<St> {
+        type Book = St::Book;
+        type Contents = Set<members::contents>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `contents` field
-        pub struct contents(());
         ///Marker type for the `book` field
         pub struct book(());
+        ///Marker type for the `contents` field
+        pub struct contents(());
     }
 }
 
@@ -211,8 +211,8 @@ where
 impl<S: BosStr, St> EntryBuilder<S, St>
 where
     St: entry_state::State,
-    St::Contents: entry_state::IsSet,
     St::Book: entry_state::IsSet,
+    St::Contents: entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Entry<S> {
diff --git a/crates/jacquard-api/src/directory_evnt/event.rs b/crates/jacquard-api/src/directory_evnt/event.rs
index 31b4f830..870d17c7 100644
--- a/crates/jacquard-api/src/directory_evnt/event.rs
+++ b/crates/jacquard-api/src/directory_evnt/event.rs
@@ -663,37 +663,37 @@ pub mod coordinates_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Lat;
         type Lng;
+        type Lat;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Lat = Unset;
         type Lng = Unset;
-    }
-    ///State transition - sets the `lat` field to Set
-    pub struct SetLat<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLat<St> {}
-    impl<St: State> State for SetLat<St> {
-        type Lat = Set<members::lat>;
-        type Lng = St::Lng;
+        type Lat = Unset;
     }
     ///State transition - sets the `lng` field to Set
     pub struct SetLng<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLng<St> {}
     impl<St: State> State for SetLng<St> {
-        type Lat = St::Lat;
         type Lng = Set<members::lng>;
+        type Lat = St::Lat;
+    }
+    ///State transition - sets the `lat` field to Set
+    pub struct SetLat<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLat<St> {}
+    impl<St: State> State for SetLat<St> {
+        type Lng = St::Lng;
+        type Lat = Set<members::lat>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `lat` field
-        pub struct lat(());
         ///Marker type for the `lng` field
         pub struct lng(());
+        ///Marker type for the `lat` field
+        pub struct lat(());
     }
 }
 
@@ -763,8 +763,8 @@ where
 impl<S: BosStr, St> CoordinatesBuilder<S, St>
 where
     St: coordinates_state::State,
-    St::Lat: coordinates_state::IsSet,
     St::Lng: coordinates_state::IsSet,
+    St::Lat: coordinates_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Coordinates<S> {
@@ -1116,51 +1116,51 @@ pub mod physical_venue_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Id;
         type Name;
         type Type;
-        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Id = Unset;
         type Name = Unset;
         type Type = Unset;
-        type Id = Unset;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
+        type Name = St::Name;
+        type Type = St::Type;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type Id = St::Id;
         type Name = Set<members::name>;
         type Type = St::Type;
-        type Id = St::Id;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type Name = St::Name;
-        type Type = Set<members::r#type>;
         type Id = St::Id;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
         type Name = St::Name;
-        type Type = St::Type;
-        type Id = Set<members::id>;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `type` field
         pub struct r#type(());
-        ///Marker type for the `id` field
-        pub struct id(());
     }
 }
 
@@ -1275,9 +1275,9 @@ where
 impl<S: BosStr, St> PhysicalVenueBuilder<S, St>
 where
     St: physical_venue_state::State,
+    St::Id: physical_venue_state::IsSet,
     St::Name: physical_venue_state::IsSet,
     St::Type: physical_venue_state::IsSet,
-    St::Id: physical_venue_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PhysicalVenue<S> {
@@ -1316,51 +1316,51 @@ pub mod unknown_venue_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Type;
         type Name;
         type Id;
-        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Type = Unset;
         type Name = Unset;
         type Id = Unset;
-        type Type = Unset;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Type = Set<members::r#type>;
+        type Name = St::Name;
+        type Id = St::Id;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type Type = St::Type;
         type Name = Set<members::name>;
         type Id = St::Id;
-        type Type = St::Type;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Name = St::Name;
-        type Id = Set<members::id>;
         type Type = St::Type;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
         type Name = St::Name;
-        type Id = St::Id;
-        type Type = Set<members::r#type>;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `type` field
+        pub struct r#type(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
     }
 }
 
@@ -1449,9 +1449,9 @@ where
 impl<S: BosStr, St> UnknownVenueBuilder<S, St>
 where
     St: unknown_venue_state::State,
+    St::Type: unknown_venue_state::IsSet,
     St::Name: unknown_venue_state::IsSet,
     St::Id: unknown_venue_state::IsSet,
-    St::Type: unknown_venue_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UnknownVenue<S> {
@@ -1486,37 +1486,37 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type V;
         type Name;
+        type V;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type V = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `v` field to Set
-    pub struct SetV<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetV<St> {}
-    impl<St: State> State for SetV<St> {
-        type V = Set<members::v>;
-        type Name = St::Name;
+        type V = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type V = St::V;
         type Name = Set<members::name>;
+        type V = St::V;
+    }
+    ///State transition - sets the `v` field to Set
+    pub struct SetV<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetV<St> {}
+    impl<St: State> State for SetV<St> {
+        type Name = St::Name;
+        type V = Set<members::v>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `v` field
-        pub struct v(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `v` field
+        pub struct v(());
     }
 }
 
@@ -1656,8 +1656,8 @@ impl<S: BosStr, St: event_state::State> EventBuilder<S, St> {
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::V: event_state::IsSet,
     St::Name: event_state::IsSet,
+    St::V: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/fact.rs b/crates/jacquard-api/src/diy_razorgirl/winter/fact.rs
index b6f05fc5..804146e0 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/fact.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/fact.rs
@@ -157,51 +157,51 @@ pub mod fact_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Predicate;
         type Args;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Predicate = Unset;
         type Args = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Predicate = St::Predicate;
-        type Args = St::Args;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `predicate` field to Set
     pub struct SetPredicate<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPredicate<St> {}
     impl<St: State> State for SetPredicate<St> {
-        type CreatedAt = St::CreatedAt;
         type Predicate = Set<members::predicate>;
         type Args = St::Args;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `args` field to Set
     pub struct SetArgs<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetArgs<St> {}
     impl<St: State> State for SetArgs<St> {
-        type CreatedAt = St::CreatedAt;
         type Predicate = St::Predicate;
         type Args = Set<members::args>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Predicate = St::Predicate;
+        type Args = St::Args;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `predicate` field
         pub struct predicate(());
         ///Marker type for the `args` field
         pub struct args(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -364,9 +364,9 @@ impl<S: BosStr, St: fact_state::State> FactBuilder<S, St> {
 impl<S: BosStr, St> FactBuilder<S, St>
 where
     St: fact_state::State,
-    St::CreatedAt: fact_state::IsSet,
     St::Predicate: fact_state::IsSet,
     St::Args: fact_state::IsSet,
+    St::CreatedAt: fact_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Fact<S> {
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/job.rs b/crates/jacquard-api/src/diy_razorgirl/winter/job.rs
index 79232a6f..39032a93 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/job.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/job.rs
@@ -293,37 +293,37 @@ pub mod interval_schedule_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type Seconds;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type Seconds = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type Seconds = St::Seconds;
+        type Type = Unset;
     }
     ///State transition - sets the `seconds` field to Set
     pub struct SetSeconds<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeconds<St> {}
     impl<St: State> State for SetSeconds<St> {
-        type Type = St::Type;
         type Seconds = Set<members::seconds>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Seconds = St::Seconds;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `seconds` field
         pub struct seconds(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -393,8 +393,8 @@ where
 impl<S: BosStr, St> IntervalScheduleBuilder<S, St>
 where
     St: interval_schedule_state::State,
-    St::Type: interval_schedule_state::IsSet,
     St::Seconds: interval_schedule_state::IsSet,
+    St::Type: interval_schedule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> IntervalSchedule<S> {
@@ -576,67 +576,67 @@ pub mod job_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Instructions;
         type Schedule;
-        type CreatedAt;
+        type Instructions;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Instructions = Unset;
         type Schedule = Unset;
-        type CreatedAt = Unset;
+        type Instructions = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `instructions` field to Set
-    pub struct SetInstructions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetInstructions<St> {}
-    impl<St: State> State for SetInstructions<St> {
-        type Instructions = Set<members::instructions>;
-        type Schedule = St::Schedule;
-        type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `schedule` field to Set
     pub struct SetSchedule<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSchedule<St> {}
     impl<St: State> State for SetSchedule<St> {
-        type Instructions = St::Instructions;
         type Schedule = Set<members::schedule>;
-        type CreatedAt = St::CreatedAt;
+        type Instructions = St::Instructions;
         type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Instructions = St::Instructions;
+    ///State transition - sets the `instructions` field to Set
+    pub struct SetInstructions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetInstructions<St> {}
+    impl<St: State> State for SetInstructions<St> {
         type Schedule = St::Schedule;
-        type CreatedAt = Set<members::created_at>;
+        type Instructions = Set<members::instructions>;
         type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Instructions = St::Instructions;
         type Schedule = St::Schedule;
-        type CreatedAt = St::CreatedAt;
+        type Instructions = St::Instructions;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Schedule = St::Schedule;
+        type Instructions = St::Instructions;
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `instructions` field
-        pub struct instructions(());
         ///Marker type for the `schedule` field
         pub struct schedule(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `instructions` field
+        pub struct instructions(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -802,10 +802,10 @@ impl<S: BosStr, St: job_state::State> JobBuilder<S, St> {
 impl<S: BosStr, St> JobBuilder<S, St>
 where
     St: job_state::State,
-    St::Instructions: job_state::IsSet,
     St::Schedule: job_state::IsSet,
-    St::CreatedAt: job_state::IsSet,
+    St::Instructions: job_state::IsSet,
     St::Name: job_state::IsSet,
+    St::CreatedAt: job_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Job<S> {
@@ -847,37 +847,37 @@ pub mod once_schedule_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type RunAt;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type RunAt = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type RunAt = St::RunAt;
+        type Type = Unset;
     }
     ///State transition - sets the `run_at` field to Set
     pub struct SetRunAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRunAt<St> {}
     impl<St: State> State for SetRunAt<St> {
-        type Type = St::Type;
         type RunAt = Set<members::run_at>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type RunAt = St::RunAt;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `run_at` field
         pub struct run_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -947,8 +947,8 @@ where
 impl<S: BosStr, St> OnceScheduleBuilder<S, St>
 where
     St: once_schedule_state::State,
-    St::Type: once_schedule_state::IsSet,
     St::RunAt: once_schedule_state::IsSet,
+    St::Type: once_schedule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> OnceSchedule<S> {
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/note.rs b/crates/jacquard-api/src/diy_razorgirl/winter/note.rs
index 8ac5fbae..176b4b38 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/note.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/note.rs
@@ -162,65 +162,65 @@ pub mod note_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type LastUpdated;
-        type CreatedAt;
         type Content;
+        type CreatedAt;
+        type LastUpdated;
         type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type LastUpdated = Unset;
-        type CreatedAt = Unset;
         type Content = Unset;
+        type CreatedAt = Unset;
+        type LastUpdated = Unset;
         type Title = Unset;
     }
-    ///State transition - sets the `last_updated` field to Set
-    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
-    impl<St: State> State for SetLastUpdated<St> {
-        type LastUpdated = Set<members::last_updated>;
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Content = Set<members::content>;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
+        type LastUpdated = St::LastUpdated;
         type Title = St::Title;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type LastUpdated = St::LastUpdated;
-        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
+        type CreatedAt = Set<members::created_at>;
+        type LastUpdated = St::LastUpdated;
         type Title = St::Title;
     }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type LastUpdated = St::LastUpdated;
+    ///State transition - sets the `last_updated` field to Set
+    pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
+    impl<St: State> State for SetLastUpdated<St> {
+        type Content = St::Content;
         type CreatedAt = St::CreatedAt;
-        type Content = Set<members::content>;
+        type LastUpdated = Set<members::last_updated>;
         type Title = St::Title;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type LastUpdated = St::LastUpdated;
-        type CreatedAt = St::CreatedAt;
         type Content = St::Content;
+        type CreatedAt = St::CreatedAt;
+        type LastUpdated = St::LastUpdated;
         type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `last_updated` field
-        pub struct last_updated(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `last_updated` field
+        pub struct last_updated(());
         ///Marker type for the `title` field
         pub struct title(());
     }
@@ -377,9 +377,9 @@ where
 impl<S: BosStr, St> NoteBuilder<S, St>
 where
     St: note_state::State,
-    St::LastUpdated: note_state::IsSet,
-    St::CreatedAt: note_state::IsSet,
     St::Content: note_state::IsSet,
+    St::CreatedAt: note_state::IsSet,
+    St::LastUpdated: note_state::IsSet,
     St::Title: note_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/tool.rs b/crates/jacquard-api/src/diy_razorgirl/winter/tool.rs
index 7dad0235..86aa7f12 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/tool.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/tool.rs
@@ -165,84 +165,84 @@ pub mod tool_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type InputSchema;
-        type Code;
         type Description;
-        type CreatedAt;
         type Name;
+        type Code;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type InputSchema = Unset;
-        type Code = Unset;
         type Description = Unset;
-        type CreatedAt = Unset;
         type Name = Unset;
+        type Code = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `input_schema` field to Set
     pub struct SetInputSchema<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetInputSchema<St> {}
     impl<St: State> State for SetInputSchema<St> {
         type InputSchema = Set<members::input_schema>;
-        type Code = St::Code;
         type Description = St::Description;
-        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
-    }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
-        type InputSchema = St::InputSchema;
-        type Code = Set<members::code>;
-        type Description = St::Description;
+        type Code = St::Code;
         type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
         type InputSchema = St::InputSchema;
-        type Code = St::Code;
         type Description = Set<members::description>;
-        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type InputSchema = St::InputSchema;
         type Code = St::Code;
-        type Description = St::Description;
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type InputSchema = St::InputSchema;
+        type Description = St::Description;
+        type Name = Set<members::name>;
         type Code = St::Code;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
+        type InputSchema = St::InputSchema;
         type Description = St::Description;
+        type Name = St::Name;
+        type Code = Set<members::code>;
         type CreatedAt = St::CreatedAt;
-        type Name = Set<members::name>;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type InputSchema = St::InputSchema;
+        type Description = St::Description;
+        type Name = St::Name;
+        type Code = St::Code;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `input_schema` field
         pub struct input_schema(());
-        ///Marker type for the `code` field
-        pub struct code(());
         ///Marker type for the `description` field
         pub struct description(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `code` field
+        pub struct code(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -487,10 +487,10 @@ impl<S: BosStr, St> ToolBuilder<S, St>
 where
     St: tool_state::State,
     St::InputSchema: tool_state::IsSet,
-    St::Code: tool_state::IsSet,
     St::Description: tool_state::IsSet,
-    St::CreatedAt: tool_state::IsSet,
     St::Name: tool_state::IsSet,
+    St::Code: tool_state::IsSet,
+    St::CreatedAt: tool_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Tool<S> {
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/wiki_entry.rs b/crates/jacquard-api/src/diy_razorgirl/winter/wiki_entry.rs
index 8b29dd96..f6c2ae3f 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/wiki_entry.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/wiki_entry.rs
@@ -272,84 +272,84 @@ pub mod wiki_entry_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Title;
+        type Content;
+        type CreatedAt;
         type LastUpdated;
         type Slug;
-        type CreatedAt;
-        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Title = Unset;
+        type Content = Unset;
+        type CreatedAt = Unset;
         type LastUpdated = Unset;
         type Slug = Unset;
-        type CreatedAt = Unset;
-        type Content = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
         type Title = Set<members::title>;
+        type Content = St::Content;
+        type CreatedAt = St::CreatedAt;
         type LastUpdated = St::LastUpdated;
         type Slug = St::Slug;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Title = St::Title;
+        type Content = Set<members::content>;
         type CreatedAt = St::CreatedAt;
+        type LastUpdated = St::LastUpdated;
+        type Slug = St::Slug;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
         type Content = St::Content;
+        type CreatedAt = Set<members::created_at>;
+        type LastUpdated = St::LastUpdated;
+        type Slug = St::Slug;
     }
     ///State transition - sets the `last_updated` field to Set
     pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
     impl<St: State> State for SetLastUpdated<St> {
         type Title = St::Title;
+        type Content = St::Content;
+        type CreatedAt = St::CreatedAt;
         type LastUpdated = Set<members::last_updated>;
         type Slug = St::Slug;
-        type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlug<St> {}
     impl<St: State> State for SetSlug<St> {
         type Title = St::Title;
-        type LastUpdated = St::LastUpdated;
-        type Slug = Set<members::slug>;
-        type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Title = St::Title;
-        type LastUpdated = St::LastUpdated;
-        type Slug = St::Slug;
-        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Title = St::Title;
-        type LastUpdated = St::LastUpdated;
-        type Slug = St::Slug;
         type CreatedAt = St::CreatedAt;
-        type Content = Set<members::content>;
+        type LastUpdated = St::LastUpdated;
+        type Slug = Set<members::slug>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `content` field
+        pub struct content(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `last_updated` field
         pub struct last_updated(());
         ///Marker type for the `slug` field
         pub struct slug(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `content` field
-        pub struct content(());
     }
 }
 
@@ -553,10 +553,10 @@ impl<S: BosStr, St> WikiEntryBuilder<S, St>
 where
     St: wiki_entry_state::State,
     St::Title: wiki_entry_state::IsSet,
+    St::Content: wiki_entry_state::IsSet,
+    St::CreatedAt: wiki_entry_state::IsSet,
     St::LastUpdated: wiki_entry_state::IsSet,
     St::Slug: wiki_entry_state::IsSet,
-    St::CreatedAt: wiki_entry_state::IsSet,
-    St::Content: wiki_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WikiEntry<S> {
diff --git a/crates/jacquard-api/src/diy_razorgirl/winter/wiki_link.rs b/crates/jacquard-api/src/diy_razorgirl/winter/wiki_link.rs
index e4845eb5..418a2709 100644
--- a/crates/jacquard-api/src/diy_razorgirl/winter/wiki_link.rs
+++ b/crates/jacquard-api/src/diy_razorgirl/winter/wiki_link.rs
@@ -238,65 +238,65 @@ pub mod wiki_link_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type LinkType;
         type Target;
         type Source;
-        type LinkType;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type LinkType = Unset;
         type Target = Unset;
         type Source = Unset;
-        type LinkType = Unset;
         type CreatedAt = Unset;
     }
+    ///State transition - sets the `link_type` field to Set
+    pub struct SetLinkType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLinkType<St> {}
+    impl<St: State> State for SetLinkType<St> {
+        type LinkType = Set<members::link_type>;
+        type Target = St::Target;
+        type Source = St::Source;
+        type CreatedAt = St::CreatedAt;
+    }
     ///State transition - sets the `target` field to Set
     pub struct SetTarget<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTarget<St> {}
     impl<St: State> State for SetTarget<St> {
+        type LinkType = St::LinkType;
         type Target = Set<members::target>;
         type Source = St::Source;
-        type LinkType = St::LinkType;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `source` field to Set
     pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSource<St> {}
     impl<St: State> State for SetSource<St> {
-        type Target = St::Target;
-        type Source = Set<members::source>;
         type LinkType = St::LinkType;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `link_type` field to Set
-    pub struct SetLinkType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLinkType<St> {}
-    impl<St: State> State for SetLinkType<St> {
         type Target = St::Target;
-        type Source = St::Source;
-        type LinkType = Set<members::link_type>;
+        type Source = Set<members::source>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type LinkType = St::LinkType;
         type Target = St::Target;
         type Source = St::Source;
-        type LinkType = St::LinkType;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `link_type` field
+        pub struct link_type(());
         ///Marker type for the `target` field
         pub struct target(());
         ///Marker type for the `source` field
         pub struct source(());
-        ///Marker type for the `link_type` field
-        pub struct link_type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -453,9 +453,9 @@ impl<S: BosStr, St: wiki_link_state::State> WikiLinkBuilder<S, St> {
 impl<S: BosStr, St> WikiLinkBuilder<S, St>
 where
     St: wiki_link_state::State,
+    St::LinkType: wiki_link_state::IsSet,
     St::Target: wiki_link_state::IsSet,
     St::Source: wiki_link_state::IsSet,
-    St::LinkType: wiki_link_state::IsSet,
     St::CreatedAt: wiki_link_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/download_darkworld/site/get_state.rs b/crates/jacquard-api/src/download_darkworld/site/get_state.rs
index 8f99d4b0..a2e5f31d 100644
--- a/crates/jacquard-api/src/download_darkworld/site/get_state.rs
+++ b/crates/jacquard-api/src/download_darkworld/site/get_state.rs
@@ -194,67 +194,45 @@ pub mod output_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type FavoriteGames;
         type TitleColors;
-        type UseSusieProphecy;
-        type FavoriteArtists;
-        type FavoriteDeltaruneCharacters;
         type FavoriteAlbums;
+        type FavoriteDeltaruneCharacters;
+        type FavoriteArtists;
+        type FavoriteGames;
+        type UseSusieProphecy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type FavoriteGames = Unset;
         type TitleColors = Unset;
-        type UseSusieProphecy = Unset;
-        type FavoriteArtists = Unset;
-        type FavoriteDeltaruneCharacters = Unset;
         type FavoriteAlbums = Unset;
-    }
-    ///State transition - sets the `favorite_games` field to Set
-    pub struct SetFavoriteGames<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFavoriteGames<St> {}
-    impl<St: State> State for SetFavoriteGames<St> {
-        type FavoriteGames = Set<members::favorite_games>;
-        type TitleColors = St::TitleColors;
-        type UseSusieProphecy = St::UseSusieProphecy;
-        type FavoriteArtists = St::FavoriteArtists;
-        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
-        type FavoriteAlbums = St::FavoriteAlbums;
+        type FavoriteDeltaruneCharacters = Unset;
+        type FavoriteArtists = Unset;
+        type FavoriteGames = Unset;
+        type UseSusieProphecy = Unset;
     }
     ///State transition - sets the `title_colors` field to Set
     pub struct SetTitleColors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitleColors<St> {}
     impl<St: State> State for SetTitleColors<St> {
-        type FavoriteGames = St::FavoriteGames;
         type TitleColors = Set<members::title_colors>;
-        type UseSusieProphecy = St::UseSusieProphecy;
-        type FavoriteArtists = St::FavoriteArtists;
-        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
         type FavoriteAlbums = St::FavoriteAlbums;
-    }
-    ///State transition - sets the `use_susie_prophecy` field to Set
-    pub struct SetUseSusieProphecy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUseSusieProphecy<St> {}
-    impl<St: State> State for SetUseSusieProphecy<St> {
+        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
+        type FavoriteArtists = St::FavoriteArtists;
         type FavoriteGames = St::FavoriteGames;
+        type UseSusieProphecy = St::UseSusieProphecy;
+    }
+    ///State transition - sets the `favorite_albums` field to Set
+    pub struct SetFavoriteAlbums<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFavoriteAlbums<St> {}
+    impl<St: State> State for SetFavoriteAlbums<St> {
         type TitleColors = St::TitleColors;
-        type UseSusieProphecy = Set<members::use_susie_prophecy>;
-        type FavoriteArtists = St::FavoriteArtists;
+        type FavoriteAlbums = Set<members::favorite_albums>;
         type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
-        type FavoriteAlbums = St::FavoriteAlbums;
-    }
-    ///State transition - sets the `favorite_artists` field to Set
-    pub struct SetFavoriteArtists<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFavoriteArtists<St> {}
-    impl<St: State> State for SetFavoriteArtists<St> {
+        type FavoriteArtists = St::FavoriteArtists;
         type FavoriteGames = St::FavoriteGames;
-        type TitleColors = St::TitleColors;
         type UseSusieProphecy = St::UseSusieProphecy;
-        type FavoriteArtists = Set<members::favorite_artists>;
-        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
-        type FavoriteAlbums = St::FavoriteAlbums;
     }
     ///State transition - sets the `favorite_deltarune_characters` field to Set
     pub struct SetFavoriteDeltaruneCharacters<St: State = Empty>(
@@ -262,39 +240,61 @@ pub mod output_state {
     );
     impl<St: State> sealed::Sealed for SetFavoriteDeltaruneCharacters<St> {}
     impl<St: State> State for SetFavoriteDeltaruneCharacters<St> {
-        type FavoriteGames = St::FavoriteGames;
         type TitleColors = St::TitleColors;
-        type UseSusieProphecy = St::UseSusieProphecy;
-        type FavoriteArtists = St::FavoriteArtists;
-        type FavoriteDeltaruneCharacters = Set<members::favorite_deltarune_characters>;
         type FavoriteAlbums = St::FavoriteAlbums;
-    }
-    ///State transition - sets the `favorite_albums` field to Set
-    pub struct SetFavoriteAlbums<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFavoriteAlbums<St> {}
-    impl<St: State> State for SetFavoriteAlbums<St> {
+        type FavoriteDeltaruneCharacters = Set<members::favorite_deltarune_characters>;
+        type FavoriteArtists = St::FavoriteArtists;
         type FavoriteGames = St::FavoriteGames;
+        type UseSusieProphecy = St::UseSusieProphecy;
+    }
+    ///State transition - sets the `favorite_artists` field to Set
+    pub struct SetFavoriteArtists<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFavoriteArtists<St> {}
+    impl<St: State> State for SetFavoriteArtists<St> {
         type TitleColors = St::TitleColors;
+        type FavoriteAlbums = St::FavoriteAlbums;
+        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
+        type FavoriteArtists = Set<members::favorite_artists>;
+        type FavoriteGames = St::FavoriteGames;
         type UseSusieProphecy = St::UseSusieProphecy;
+    }
+    ///State transition - sets the `favorite_games` field to Set
+    pub struct SetFavoriteGames<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFavoriteGames<St> {}
+    impl<St: State> State for SetFavoriteGames<St> {
+        type TitleColors = St::TitleColors;
+        type FavoriteAlbums = St::FavoriteAlbums;
+        type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
         type FavoriteArtists = St::FavoriteArtists;
+        type FavoriteGames = Set<members::favorite_games>;
+        type UseSusieProphecy = St::UseSusieProphecy;
+    }
+    ///State transition - sets the `use_susie_prophecy` field to Set
+    pub struct SetUseSusieProphecy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUseSusieProphecy<St> {}
+    impl<St: State> State for SetUseSusieProphecy<St> {
+        type TitleColors = St::TitleColors;
+        type FavoriteAlbums = St::FavoriteAlbums;
         type FavoriteDeltaruneCharacters = St::FavoriteDeltaruneCharacters;
-        type FavoriteAlbums = Set<members::favorite_albums>;
+        type FavoriteArtists = St::FavoriteArtists;
+        type FavoriteGames = St::FavoriteGames;
+        type UseSusieProphecy = Set<members::use_susie_prophecy>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `favorite_games` field
-        pub struct favorite_games(());
         ///Marker type for the `title_colors` field
         pub struct title_colors(());
-        ///Marker type for the `use_susie_prophecy` field
-        pub struct use_susie_prophecy(());
-        ///Marker type for the `favorite_artists` field
-        pub struct favorite_artists(());
-        ///Marker type for the `favorite_deltarune_characters` field
-        pub struct favorite_deltarune_characters(());
         ///Marker type for the `favorite_albums` field
         pub struct favorite_albums(());
+        ///Marker type for the `favorite_deltarune_characters` field
+        pub struct favorite_deltarune_characters(());
+        ///Marker type for the `favorite_artists` field
+        pub struct favorite_artists(());
+        ///Marker type for the `favorite_games` field
+        pub struct favorite_games(());
+        ///Marker type for the `use_susie_prophecy` field
+        pub struct use_susie_prophecy(());
     }
 }
 
@@ -447,12 +447,12 @@ where
 impl<S: BosStr, St> OutputBuilder<S, St>
 where
     St: output_state::State,
-    St::FavoriteGames: output_state::IsSet,
     St::TitleColors: output_state::IsSet,
-    St::UseSusieProphecy: output_state::IsSet,
-    St::FavoriteArtists: output_state::IsSet,
-    St::FavoriteDeltaruneCharacters: output_state::IsSet,
     St::FavoriteAlbums: output_state::IsSet,
+    St::FavoriteDeltaruneCharacters: output_state::IsSet,
+    St::FavoriteArtists: output_state::IsSet,
+    St::FavoriteGames: output_state::IsSet,
+    St::UseSusieProphecy: output_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Output<S> {
diff --git a/crates/jacquard-api/src/eu_atchef/recipe.rs b/crates/jacquard-api/src/eu_atchef/recipe.rs
index cc99102f..0977fd3b 100644
--- a/crates/jacquard-api/src/eu_atchef/recipe.rs
+++ b/crates/jacquard-api/src/eu_atchef/recipe.rs
@@ -285,51 +285,51 @@ pub mod recipe_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Name;
         type Content;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Name = Unset;
         type Content = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+        type Content = St::Content;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Content = St::Content;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Name = St::Name;
-        type Content = Set<members::content>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Name = St::Name;
-        type Content = St::Content;
-        type CreatedAt = Set<members::created_at>;
+        type Content = Set<members::content>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `content` field
         pub struct content(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -520,9 +520,9 @@ impl<S: BosStr, St: recipe_state::State> RecipeBuilder<S, St> {
 impl<S: BosStr, St> RecipeBuilder<S, St>
 where
     St: recipe_state::State,
+    St::CreatedAt: recipe_state::IsSet,
     St::Name: recipe_state::IsSet,
     St::Content: recipe_state::IsSet,
-    St::CreatedAt: recipe_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Recipe<S> {
diff --git a/crates/jacquard-api/src/events_smokesignal/lfg.rs b/crates/jacquard-api/src/events_smokesignal/lfg.rs
index 90e30681..7c5e141f 100644
--- a/crates/jacquard-api/src/events_smokesignal/lfg.rs
+++ b/crates/jacquard-api/src/events_smokesignal/lfg.rs
@@ -150,104 +150,104 @@ pub mod lfg_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Active;
+        type StartsAt;
         type EndsAt;
+        type Location;
         type Tags;
-        type StartsAt;
         type CreatedAt;
-        type Location;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Active = Unset;
+        type StartsAt = Unset;
         type EndsAt = Unset;
+        type Location = Unset;
         type Tags = Unset;
-        type StartsAt = Unset;
         type CreatedAt = Unset;
-        type Location = Unset;
     }
     ///State transition - sets the `active` field to Set
     pub struct SetActive<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActive<St> {}
     impl<St: State> State for SetActive<St> {
         type Active = Set<members::active>;
+        type StartsAt = St::StartsAt;
         type EndsAt = St::EndsAt;
+        type Location = St::Location;
         type Tags = St::Tags;
-        type StartsAt = St::StartsAt;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `starts_at` field to Set
+    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
+    impl<St: State> State for SetStartsAt<St> {
+        type Active = St::Active;
+        type StartsAt = Set<members::starts_at>;
+        type EndsAt = St::EndsAt;
         type Location = St::Location;
+        type Tags = St::Tags;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `ends_at` field to Set
     pub struct SetEndsAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEndsAt<St> {}
     impl<St: State> State for SetEndsAt<St> {
         type Active = St::Active;
+        type StartsAt = St::StartsAt;
         type EndsAt = Set<members::ends_at>;
+        type Location = St::Location;
         type Tags = St::Tags;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `location` field to Set
+    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLocation<St> {}
+    impl<St: State> State for SetLocation<St> {
+        type Active = St::Active;
         type StartsAt = St::StartsAt;
+        type EndsAt = St::EndsAt;
+        type Location = Set<members::location>;
+        type Tags = St::Tags;
         type CreatedAt = St::CreatedAt;
-        type Location = St::Location;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
         type Active = St::Active;
-        type EndsAt = St::EndsAt;
-        type Tags = Set<members::tags>;
         type StartsAt = St::StartsAt;
-        type CreatedAt = St::CreatedAt;
-        type Location = St::Location;
-    }
-    ///State transition - sets the `starts_at` field to Set
-    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
-    impl<St: State> State for SetStartsAt<St> {
-        type Active = St::Active;
         type EndsAt = St::EndsAt;
-        type Tags = St::Tags;
-        type StartsAt = Set<members::starts_at>;
-        type CreatedAt = St::CreatedAt;
         type Location = St::Location;
+        type Tags = Set<members::tags>;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Active = St::Active;
-        type EndsAt = St::EndsAt;
-        type Tags = St::Tags;
         type StartsAt = St::StartsAt;
-        type CreatedAt = Set<members::created_at>;
-        type Location = St::Location;
-    }
-    ///State transition - sets the `location` field to Set
-    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLocation<St> {}
-    impl<St: State> State for SetLocation<St> {
-        type Active = St::Active;
         type EndsAt = St::EndsAt;
+        type Location = St::Location;
         type Tags = St::Tags;
-        type StartsAt = St::StartsAt;
-        type CreatedAt = St::CreatedAt;
-        type Location = Set<members::location>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `active` field
         pub struct active(());
+        ///Marker type for the `starts_at` field
+        pub struct starts_at(());
         ///Marker type for the `ends_at` field
         pub struct ends_at(());
+        ///Marker type for the `location` field
+        pub struct location(());
         ///Marker type for the `tags` field
         pub struct tags(());
-        ///Marker type for the `starts_at` field
-        pub struct starts_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `location` field
-        pub struct location(());
     }
 }
 
@@ -401,11 +401,11 @@ impl<S: BosStr, St> LfgBuilder<S, St>
 where
     St: lfg_state::State,
     St::Active: lfg_state::IsSet,
+    St::StartsAt: lfg_state::IsSet,
     St::EndsAt: lfg_state::IsSet,
+    St::Location: lfg_state::IsSet,
     St::Tags: lfg_state::IsSet,
-    St::StartsAt: lfg_state::IsSet,
     St::CreatedAt: lfg_state::IsSet,
-    St::Location: lfg_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Lfg<S> {
diff --git a/crates/jacquard-api/src/fm_teal/alpha/feed.rs b/crates/jacquard-api/src/fm_teal/alpha/feed.rs
index df3aa776..1f68deff 100644
--- a/crates/jacquard-api/src/fm_teal/alpha/feed.rs
+++ b/crates/jacquard-api/src/fm_teal/alpha/feed.rs
@@ -434,37 +434,37 @@ pub mod play_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Artists;
         type TrackName;
+        type Artists;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Artists = Unset;
         type TrackName = Unset;
-    }
-    ///State transition - sets the `artists` field to Set
-    pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtists<St> {}
-    impl<St: State> State for SetArtists<St> {
-        type Artists = Set<members::artists>;
-        type TrackName = St::TrackName;
+        type Artists = Unset;
     }
     ///State transition - sets the `track_name` field to Set
     pub struct SetTrackName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTrackName<St> {}
     impl<St: State> State for SetTrackName<St> {
-        type Artists = St::Artists;
         type TrackName = Set<members::track_name>;
+        type Artists = St::Artists;
+    }
+    ///State transition - sets the `artists` field to Set
+    pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtists<St> {}
+    impl<St: State> State for SetArtists<St> {
+        type TrackName = St::TrackName;
+        type Artists = Set<members::artists>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artists` field
-        pub struct artists(());
         ///Marker type for the `track_name` field
         pub struct track_name(());
+        ///Marker type for the `artists` field
+        pub struct artists(());
     }
 }
 
@@ -690,8 +690,8 @@ where
 impl<S: BosStr, St> PlayViewBuilder<S, St>
 where
     St: play_view_state::State,
-    St::Artists: play_view_state::IsSet,
     St::TrackName: play_view_state::IsSet,
+    St::Artists: play_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlayView<S> {
diff --git a/crates/jacquard-api/src/fm_teal/alpha/stats.rs b/crates/jacquard-api/src/fm_teal/alpha/stats.rs
index b393bb51..8947ef2e 100644
--- a/crates/jacquard-api/src/fm_teal/alpha/stats.rs
+++ b/crates/jacquard-api/src/fm_teal/alpha/stats.rs
@@ -127,51 +127,51 @@ pub mod artist_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type PlayCount;
         type Mbid;
+        type PlayCount;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type PlayCount = Unset;
         type Mbid = Unset;
+        type PlayCount = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `mbid` field to Set
+    pub struct SetMbid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMbid<St> {}
+    impl<St: State> State for SetMbid<St> {
+        type Mbid = Set<members::mbid>;
         type PlayCount = St::PlayCount;
-        type Mbid = St::Mbid;
+        type Name = St::Name;
     }
     ///State transition - sets the `play_count` field to Set
     pub struct SetPlayCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlayCount<St> {}
     impl<St: State> State for SetPlayCount<St> {
-        type Name = St::Name;
-        type PlayCount = Set<members::play_count>;
         type Mbid = St::Mbid;
-    }
-    ///State transition - sets the `mbid` field to Set
-    pub struct SetMbid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMbid<St> {}
-    impl<St: State> State for SetMbid<St> {
+        type PlayCount = Set<members::play_count>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Mbid = St::Mbid;
         type PlayCount = St::PlayCount;
-        type Mbid = Set<members::mbid>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `play_count` field
-        pub struct play_count(());
         ///Marker type for the `mbid` field
         pub struct mbid(());
+        ///Marker type for the `play_count` field
+        pub struct play_count(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -260,9 +260,9 @@ where
 impl<S: BosStr, St> ArtistViewBuilder<S, St>
 where
     St: artist_view_state::State,
-    St::Name: artist_view_state::IsSet,
-    St::PlayCount: artist_view_state::IsSet,
     St::Mbid: artist_view_state::IsSet,
+    St::PlayCount: artist_view_state::IsSet,
+    St::Name: artist_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ArtistView<S> {
@@ -432,51 +432,51 @@ pub mod recording_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Name;
         type PlayCount;
         type Mbid;
-        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Name = Unset;
         type PlayCount = Unset;
         type Mbid = Unset;
-        type Name = Unset;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
+        type PlayCount = St::PlayCount;
+        type Mbid = St::Mbid;
     }
     ///State transition - sets the `play_count` field to Set
     pub struct SetPlayCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlayCount<St> {}
     impl<St: State> State for SetPlayCount<St> {
+        type Name = St::Name;
         type PlayCount = Set<members::play_count>;
         type Mbid = St::Mbid;
-        type Name = St::Name;
     }
     ///State transition - sets the `mbid` field to Set
     pub struct SetMbid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMbid<St> {}
     impl<St: State> State for SetMbid<St> {
-        type PlayCount = St::PlayCount;
-        type Mbid = Set<members::mbid>;
         type Name = St::Name;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type PlayCount = St::PlayCount;
-        type Mbid = St::Mbid;
-        type Name = Set<members::name>;
+        type Mbid = Set<members::mbid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `play_count` field
         pub struct play_count(());
         ///Marker type for the `mbid` field
         pub struct mbid(());
-        ///Marker type for the `name` field
-        pub struct name(());
     }
 }
 
@@ -565,9 +565,9 @@ where
 impl<S: BosStr, St> RecordingViewBuilder<S, St>
 where
     St: recording_view_state::State,
+    St::Name: recording_view_state::IsSet,
     St::PlayCount: recording_view_state::IsSet,
     St::Mbid: recording_view_state::IsSet,
-    St::Name: recording_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RecordingView<S> {
@@ -602,51 +602,51 @@ pub mod release_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type PlayCount;
         type Name;
         type Mbid;
+        type PlayCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type PlayCount = Unset;
         type Name = Unset;
         type Mbid = Unset;
-    }
-    ///State transition - sets the `play_count` field to Set
-    pub struct SetPlayCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlayCount<St> {}
-    impl<St: State> State for SetPlayCount<St> {
-        type PlayCount = Set<members::play_count>;
-        type Name = St::Name;
-        type Mbid = St::Mbid;
+        type PlayCount = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type PlayCount = St::PlayCount;
         type Name = Set<members::name>;
         type Mbid = St::Mbid;
+        type PlayCount = St::PlayCount;
     }
     ///State transition - sets the `mbid` field to Set
     pub struct SetMbid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMbid<St> {}
     impl<St: State> State for SetMbid<St> {
-        type PlayCount = St::PlayCount;
         type Name = St::Name;
         type Mbid = Set<members::mbid>;
+        type PlayCount = St::PlayCount;
+    }
+    ///State transition - sets the `play_count` field to Set
+    pub struct SetPlayCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlayCount<St> {}
+    impl<St: State> State for SetPlayCount<St> {
+        type Name = St::Name;
+        type Mbid = St::Mbid;
+        type PlayCount = Set<members::play_count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `play_count` field
-        pub struct play_count(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `mbid` field
         pub struct mbid(());
+        ///Marker type for the `play_count` field
+        pub struct play_count(());
     }
 }
 
@@ -735,9 +735,9 @@ where
 impl<S: BosStr, St> ReleaseViewBuilder<S, St>
 where
     St: release_view_state::State,
-    St::PlayCount: release_view_state::IsSet,
     St::Name: release_view_state::IsSet,
     St::Mbid: release_view_state::IsSet,
+    St::PlayCount: release_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReleaseView<S> {
diff --git a/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs b/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs
index 2d2d1cda..d6bc7b93 100644
--- a/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs
+++ b/crates/jacquard-api/src/fyi_frontpage/feed/comment.rs
@@ -130,51 +130,51 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Post;
-        type CreatedAt;
         type Blocks;
+        type CreatedAt;
+        type Post;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Post = Unset;
-        type CreatedAt = Unset;
         type Blocks = Unset;
+        type CreatedAt = Unset;
+        type Post = Unset;
     }
-    ///State transition - sets the `post` field to Set
-    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPost<St> {}
-    impl<St: State> State for SetPost<St> {
-        type Post = Set<members::post>;
+    ///State transition - sets the `blocks` field to Set
+    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlocks<St> {}
+    impl<St: State> State for SetBlocks<St> {
+        type Blocks = Set<members::blocks>;
         type CreatedAt = St::CreatedAt;
-        type Blocks = St::Blocks;
+        type Post = St::Post;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Post = St::Post;
-        type CreatedAt = Set<members::created_at>;
         type Blocks = St::Blocks;
-    }
-    ///State transition - sets the `blocks` field to Set
-    pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlocks<St> {}
-    impl<St: State> State for SetBlocks<St> {
+        type CreatedAt = Set<members::created_at>;
         type Post = St::Post;
+    }
+    ///State transition - sets the `post` field to Set
+    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPost<St> {}
+    impl<St: State> State for SetPost<St> {
+        type Blocks = St::Blocks;
         type CreatedAt = St::CreatedAt;
-        type Blocks = Set<members::blocks>;
+        type Post = Set<members::post>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `post` field
-        pub struct post(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `blocks` field
         pub struct blocks(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `post` field
+        pub struct post(());
     }
 }
 
@@ -281,9 +281,9 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::Post: comment_state::IsSet,
-    St::CreatedAt: comment_state::IsSet,
     St::Blocks: comment_state::IsSet,
+    St::CreatedAt: comment_state::IsSet,
+    St::Post: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/fyi_frontpage/feed/post.rs b/crates/jacquard-api/src/fyi_frontpage/feed/post.rs
index 41eefe10..29650eb2 100644
--- a/crates/jacquard-api/src/fyi_frontpage/feed/post.rs
+++ b/crates/jacquard-api/src/fyi_frontpage/feed/post.rs
@@ -166,50 +166,50 @@ pub mod post_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Title;
         type Subject;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Title = Unset;
         type Subject = Unset;
+        type Title = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
-        type Subject = St::Subject;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
         type Subject = St::Subject;
+        type Title = St::Title;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
         type Subject = Set<members::subject>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -299,8 +299,8 @@ impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
     St::CreatedAt: post_state::IsSet,
-    St::Title: post_state::IsSet,
     St::Subject: post_state::IsSet,
+    St::Title: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/fyi_questionable/answer.rs b/crates/jacquard-api/src/fyi_questionable/answer.rs
index 9f7b34a6..5c4d9996 100644
--- a/crates/jacquard-api/src/fyi_questionable/answer.rs
+++ b/crates/jacquard-api/src/fyi_questionable/answer.rs
@@ -128,51 +128,51 @@ pub mod answer_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Content;
         type Question;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Content = Unset;
         type Question = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Content = St::Content;
+        type Question = St::Question;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
+        type CreatedAt = St::CreatedAt;
         type Content = Set<members::content>;
         type Question = St::Question;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `question` field to Set
     pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetQuestion<St> {}
     impl<St: State> State for SetQuestion<St> {
-        type Content = St::Content;
-        type Question = Set<members::question>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Content = St::Content;
-        type Question = St::Question;
-        type CreatedAt = Set<members::created_at>;
+        type Question = Set<members::question>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `content` field
         pub struct content(());
         ///Marker type for the `question` field
         pub struct question(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -279,9 +279,9 @@ where
 impl<S: BosStr, St> AnswerBuilder<S, St>
 where
     St: answer_state::State,
+    St::CreatedAt: answer_state::IsSet,
     St::Content: answer_state::IsSet,
     St::Question: answer_state::IsSet,
-    St::CreatedAt: answer_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Answer<S> {
diff --git a/crates/jacquard-api/src/fyi_questionable/richtext/facet.rs b/crates/jacquard-api/src/fyi_questionable/richtext/facet.rs
index 1149ee35..d0fff207 100644
--- a/crates/jacquard-api/src/fyi_questionable/richtext/facet.rs
+++ b/crates/jacquard-api/src/fyi_questionable/richtext/facet.rs
@@ -555,37 +555,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteStart;
         type ByteEnd;
+        type ByteStart;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteStart = Unset;
         type ByteEnd = Unset;
-    }
-    ///State transition - sets the `byte_start` field to Set
-    pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteStart<St> {}
-    impl<St: State> State for SetByteStart<St> {
-        type ByteStart = Set<members::byte_start>;
-        type ByteEnd = St::ByteEnd;
+        type ByteStart = Unset;
     }
     ///State transition - sets the `byte_end` field to Set
     pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteEnd<St> {}
     impl<St: State> State for SetByteEnd<St> {
-        type ByteStart = St::ByteStart;
         type ByteEnd = Set<members::byte_end>;
+        type ByteStart = St::ByteStart;
+    }
+    ///State transition - sets the `byte_start` field to Set
+    pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteStart<St> {}
+    impl<St: State> State for SetByteStart<St> {
+        type ByteEnd = St::ByteEnd;
+        type ByteStart = Set<members::byte_start>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_start` field
-        pub struct byte_start(());
         ///Marker type for the `byte_end` field
         pub struct byte_end(());
+        ///Marker type for the `byte_start` field
+        pub struct byte_start(());
     }
 }
 
@@ -655,8 +655,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteStart: byte_slice_state::IsSet,
     St::ByteEnd: byte_slice_state::IsSet,
+    St::ByteStart: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
diff --git a/crates/jacquard-api/src/fyi_questionable/richtext/image.rs b/crates/jacquard-api/src/fyi_questionable/richtext/image.rs
index f9d098c0..eb72e071 100644
--- a/crates/jacquard-api/src/fyi_questionable/richtext/image.rs
+++ b/crates/jacquard-api/src/fyi_questionable/richtext/image.rs
@@ -367,37 +367,37 @@ pub mod image_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type AspectRatio;
+        type Image;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type AspectRatio = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type AspectRatio = St::AspectRatio;
+        type Image = Unset;
     }
     ///State transition - sets the `aspect_ratio` field to Set
     pub struct SetAspectRatio<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAspectRatio<St> {}
     impl<St: State> State for SetAspectRatio<St> {
-        type Image = St::Image;
         type AspectRatio = Set<members::aspect_ratio>;
+        type Image = St::Image;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type AspectRatio = St::AspectRatio;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `aspect_ratio` field
         pub struct aspect_ratio(());
+        ///Marker type for the `image` field
+        pub struct image(());
     }
 }
 
@@ -480,8 +480,8 @@ where
 impl<S: BosStr, St> ImageBuilder<S, St>
 where
     St: image_state::State,
-    St::Image: image_state::IsSet,
     St::AspectRatio: image_state::IsSet,
+    St::Image: image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Image<S> {
diff --git a/crates/jacquard-api/src/fyi_questionable/selected_answer.rs b/crates/jacquard-api/src/fyi_questionable/selected_answer.rs
index c107b9d3..9215f9d2 100644
--- a/crates/jacquard-api/src/fyi_questionable/selected_answer.rs
+++ b/crates/jacquard-api/src/fyi_questionable/selected_answer.rs
@@ -115,51 +115,51 @@ pub mod selected_answer_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AnswerRef;
         type CreatedAt;
         type QuestionRef;
+        type AnswerRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AnswerRef = Unset;
         type CreatedAt = Unset;
         type QuestionRef = Unset;
-    }
-    ///State transition - sets the `answer_ref` field to Set
-    pub struct SetAnswerRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAnswerRef<St> {}
-    impl<St: State> State for SetAnswerRef<St> {
-        type AnswerRef = Set<members::answer_ref>;
-        type CreatedAt = St::CreatedAt;
-        type QuestionRef = St::QuestionRef;
+        type AnswerRef = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type AnswerRef = St::AnswerRef;
         type CreatedAt = Set<members::created_at>;
         type QuestionRef = St::QuestionRef;
+        type AnswerRef = St::AnswerRef;
     }
     ///State transition - sets the `question_ref` field to Set
     pub struct SetQuestionRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetQuestionRef<St> {}
     impl<St: State> State for SetQuestionRef<St> {
-        type AnswerRef = St::AnswerRef;
         type CreatedAt = St::CreatedAt;
         type QuestionRef = Set<members::question_ref>;
+        type AnswerRef = St::AnswerRef;
+    }
+    ///State transition - sets the `answer_ref` field to Set
+    pub struct SetAnswerRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAnswerRef<St> {}
+    impl<St: State> State for SetAnswerRef<St> {
+        type CreatedAt = St::CreatedAt;
+        type QuestionRef = St::QuestionRef;
+        type AnswerRef = Set<members::answer_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `answer_ref` field
-        pub struct answer_ref(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `question_ref` field
         pub struct question_ref(());
+        ///Marker type for the `answer_ref` field
+        pub struct answer_ref(());
     }
 }
 
@@ -248,9 +248,9 @@ where
 impl<S: BosStr, St> SelectedAnswerBuilder<S, St>
 where
     St: selected_answer_state::State,
-    St::AnswerRef: selected_answer_state::IsSet,
     St::CreatedAt: selected_answer_state::IsSet,
     St::QuestionRef: selected_answer_state::IsSet,
+    St::AnswerRef: selected_answer_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SelectedAnswer<S> {
diff --git a/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs b/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs
index 9d83eadf..7b1b3847 100644
--- a/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs
+++ b/crates/jacquard-api/src/fyi_unravel/frontpage/comment.rs
@@ -142,51 +142,51 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Content;
-        type CreatedAt;
         type Post;
+        type CreatedAt;
+        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Content = Unset;
-        type CreatedAt = Unset;
         type Post = Unset;
+        type CreatedAt = Unset;
+        type Content = Unset;
     }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Content = Set<members::content>;
+    ///State transition - sets the `post` field to Set
+    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPost<St> {}
+    impl<St: State> State for SetPost<St> {
+        type Post = Set<members::post>;
         type CreatedAt = St::CreatedAt;
-        type Post = St::Post;
+        type Content = St::Content;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Content = St::Content;
-        type CreatedAt = Set<members::created_at>;
         type Post = St::Post;
-    }
-    ///State transition - sets the `post` field to Set
-    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPost<St> {}
-    impl<St: State> State for SetPost<St> {
+        type CreatedAt = Set<members::created_at>;
         type Content = St::Content;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Post = St::Post;
         type CreatedAt = St::CreatedAt;
-        type Post = Set<members::post>;
+        type Content = Set<members::content>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `content` field
-        pub struct content(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `post` field
         pub struct post(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `content` field
+        pub struct content(());
     }
 }
 
@@ -288,9 +288,9 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::Content: comment_state::IsSet,
-    St::CreatedAt: comment_state::IsSet,
     St::Post: comment_state::IsSet,
+    St::CreatedAt: comment_state::IsSet,
+    St::Content: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs b/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs
index 9e66e1a3..d7ada252 100644
--- a/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs
+++ b/crates/jacquard-api/src/fyi_unravel/frontpage/post.rs
@@ -141,50 +141,50 @@ pub mod post_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Url;
-        type CreatedAt;
         type Title;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Url = Unset;
-        type CreatedAt = Unset;
         type Title = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
         type Url = Set<members::url>;
-        type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Url = St::Url;
-        type CreatedAt = Set<members::created_at>;
         type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
         type Url = St::Url;
-        type CreatedAt = St::CreatedAt;
         type Title = Set<members::title>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Url = St::Url;
+        type Title = St::Title;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `url` field
         pub struct url(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -274,8 +274,8 @@ impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
     St::Url: post_state::IsSet,
-    St::CreatedAt: post_state::IsSet,
     St::Title: post_state::IsSet,
+    St::CreatedAt: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/games_firehose/barklesheep/place_sheeps.rs b/crates/jacquard-api/src/games_firehose/barklesheep/place_sheeps.rs
index 842462fd..e97ef922 100644
--- a/crates/jacquard-api/src/games_firehose/barklesheep/place_sheeps.rs
+++ b/crates/jacquard-api/src/games_firehose/barklesheep/place_sheeps.rs
@@ -108,37 +108,37 @@ pub mod place_sheeps_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Sheeps;
         type GameId;
+        type Sheeps;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Sheeps = Unset;
         type GameId = Unset;
-    }
-    ///State transition - sets the `sheeps` field to Set
-    pub struct SetSheeps<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSheeps<St> {}
-    impl<St: State> State for SetSheeps<St> {
-        type Sheeps = Set<members::sheeps>;
-        type GameId = St::GameId;
+        type Sheeps = Unset;
     }
     ///State transition - sets the `game_id` field to Set
     pub struct SetGameId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGameId<St> {}
     impl<St: State> State for SetGameId<St> {
-        type Sheeps = St::Sheeps;
         type GameId = Set<members::game_id>;
+        type Sheeps = St::Sheeps;
+    }
+    ///State transition - sets the `sheeps` field to Set
+    pub struct SetSheeps<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSheeps<St> {}
+    impl<St: State> State for SetSheeps<St> {
+        type GameId = St::GameId;
+        type Sheeps = Set<members::sheeps>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `sheeps` field
-        pub struct sheeps(());
         ///Marker type for the `game_id` field
         pub struct game_id(());
+        ///Marker type for the `sheeps` field
+        pub struct sheeps(());
     }
 }
 
@@ -208,8 +208,8 @@ where
 impl<S: BosStr, St> PlaceSheepsBuilder<S, St>
 where
     St: place_sheeps_state::State,
-    St::Sheeps: place_sheeps_state::IsSet,
     St::GameId: place_sheeps_state::IsSet,
+    St::Sheeps: place_sheeps_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlaceSheeps<S> {
@@ -242,51 +242,51 @@ pub mod sheep_placement_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Horizontal;
-        type Type;
         type Start;
+        type Type;
+        type Horizontal;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Horizontal = Unset;
-        type Type = Unset;
         type Start = Unset;
+        type Type = Unset;
+        type Horizontal = Unset;
     }
-    ///State transition - sets the `horizontal` field to Set
-    pub struct SetHorizontal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHorizontal<St> {}
-    impl<St: State> State for SetHorizontal<St> {
-        type Horizontal = Set<members::horizontal>;
+    ///State transition - sets the `start` field to Set
+    pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStart<St> {}
+    impl<St: State> State for SetStart<St> {
+        type Start = Set<members::start>;
         type Type = St::Type;
-        type Start = St::Start;
+        type Horizontal = St::Horizontal;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type Horizontal = St::Horizontal;
-        type Type = Set<members::r#type>;
         type Start = St::Start;
-    }
-    ///State transition - sets the `start` field to Set
-    pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStart<St> {}
-    impl<St: State> State for SetStart<St> {
+        type Type = Set<members::r#type>;
         type Horizontal = St::Horizontal;
+    }
+    ///State transition - sets the `horizontal` field to Set
+    pub struct SetHorizontal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHorizontal<St> {}
+    impl<St: State> State for SetHorizontal<St> {
+        type Start = St::Start;
         type Type = St::Type;
-        type Start = Set<members::start>;
+        type Horizontal = Set<members::horizontal>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `horizontal` field
-        pub struct horizontal(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `start` field
         pub struct start(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
+        ///Marker type for the `horizontal` field
+        pub struct horizontal(());
     }
 }
 
@@ -375,9 +375,9 @@ where
 impl<S: BosStr, St> SheepPlacementBuilder<S, St>
 where
     St: sheep_placement_state::State,
-    St::Horizontal: sheep_placement_state::IsSet,
-    St::Type: sheep_placement_state::IsSet,
     St::Start: sheep_placement_state::IsSet,
+    St::Type: sheep_placement_state::IsSet,
+    St::Horizontal: sheep_placement_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SheepPlacement<S> {
diff --git a/crates/jacquard-api/src/games_firehose/barklesheep/reaction.rs b/crates/jacquard-api/src/games_firehose/barklesheep/reaction.rs
index d3af906f..19ba1832 100644
--- a/crates/jacquard-api/src/games_firehose/barklesheep/reaction.rs
+++ b/crates/jacquard-api/src/games_firehose/barklesheep/reaction.rs
@@ -124,51 +124,51 @@ pub mod reaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Emoji;
-        type GameId;
         type CreatedAt;
+        type GameId;
+        type Emoji;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Emoji = Unset;
-        type GameId = Unset;
         type CreatedAt = Unset;
+        type GameId = Unset;
+        type Emoji = Unset;
     }
-    ///State transition - sets the `emoji` field to Set
-    pub struct SetEmoji<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEmoji<St> {}
-    impl<St: State> State for SetEmoji<St> {
-        type Emoji = Set<members::emoji>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type GameId = St::GameId;
-        type CreatedAt = St::CreatedAt;
+        type Emoji = St::Emoji;
     }
     ///State transition - sets the `game_id` field to Set
     pub struct SetGameId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGameId<St> {}
     impl<St: State> State for SetGameId<St> {
-        type Emoji = St::Emoji;
-        type GameId = Set<members::game_id>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type GameId = Set<members::game_id>;
         type Emoji = St::Emoji;
+    }
+    ///State transition - sets the `emoji` field to Set
+    pub struct SetEmoji<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEmoji<St> {}
+    impl<St: State> State for SetEmoji<St> {
+        type CreatedAt = St::CreatedAt;
         type GameId = St::GameId;
-        type CreatedAt = Set<members::created_at>;
+        type Emoji = Set<members::emoji>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `emoji` field
-        pub struct emoji(());
-        ///Marker type for the `game_id` field
-        pub struct game_id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `game_id` field
+        pub struct game_id(());
+        ///Marker type for the `emoji` field
+        pub struct emoji(());
     }
 }
 
@@ -257,9 +257,9 @@ where
 impl<S: BosStr, St> ReactionBuilder<S, St>
 where
     St: reaction_state::State,
-    St::Emoji: reaction_state::IsSet,
-    St::GameId: reaction_state::IsSet,
     St::CreatedAt: reaction_state::IsSet,
+    St::GameId: reaction_state::IsSet,
+    St::Emoji: reaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reaction<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames.rs
index 81737696..ee64a73d 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames.rs
@@ -3267,37 +3267,37 @@ pub mod actor_credit_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Credits;
         type Uri;
+        type Credits;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Credits = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `credits` field to Set
-    pub struct SetCredits<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCredits<St> {}
-    impl<St: State> State for SetCredits<St> {
-        type Credits = Set<members::credits>;
-        type Uri = St::Uri;
+        type Credits = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Credits = St::Credits;
         type Uri = Set<members::uri>;
+        type Credits = St::Credits;
+    }
+    ///State transition - sets the `credits` field to Set
+    pub struct SetCredits<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCredits<St> {}
+    impl<St: State> State for SetCredits<St> {
+        type Uri = St::Uri;
+        type Credits = Set<members::credits>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `credits` field
-        pub struct credits(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `credits` field
+        pub struct credits(());
     }
 }
 
@@ -3398,8 +3398,8 @@ where
 impl<S: BosStr, St> ActorCreditViewBuilder<S, St>
 where
     St: actor_credit_view_state::State,
-    St::Credits: actor_credit_view_state::IsSet,
     St::Uri: actor_credit_view_state::IsSet,
+    St::Credits: actor_credit_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ActorCreditView<S> {
@@ -5177,37 +5177,37 @@ pub mod actor_profile_detail_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Uri;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Uri = St::Uri;
+        type Did = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Did = St::Did;
         type Uri = Set<members::uri>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Uri = St::Uri;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -5416,8 +5416,8 @@ impl<
 impl<S: BosStr, St> ActorProfileDetailViewBuilder<S, St>
 where
     St: actor_profile_detail_view_state::State,
-    St::Did: actor_profile_detail_view_state::IsSet,
     St::Uri: actor_profile_detail_view_state::IsSet,
+    St::Did: actor_profile_detail_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ActorProfileDetailView<S> {
@@ -5464,37 +5464,37 @@ pub mod actor_profile_summary_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Did;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Did = St::Did;
+        type Uri = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Uri = St::Uri;
         type Did = Set<members::did>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Did = St::Did;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -5610,8 +5610,8 @@ where
 impl<S: BosStr, St> ActorProfileSummaryViewBuilder<S, St>
 where
     St: actor_profile_summary_view_state::State,
-    St::Uri: actor_profile_summary_view_state::IsSet,
     St::Did: actor_profile_summary_view_state::IsSet,
+    St::Uri: actor_profile_summary_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ActorProfileSummaryView<S> {
@@ -5648,37 +5648,37 @@ pub mod collection_summary_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Name;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Name = St::Name;
+        type Uri = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Uri = St::Uri;
         type Name = Set<members::name>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Name = St::Name;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -5794,8 +5794,8 @@ where
 impl<S: BosStr, St> CollectionSummaryViewBuilder<S, St>
 where
     St: collection_summary_view_state::State,
-    St::Uri: collection_summary_view_state::IsSet,
     St::Name: collection_summary_view_state::IsSet,
+    St::Uri: collection_summary_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionSummaryView<S> {
@@ -6096,51 +6096,51 @@ pub mod game_detail_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type CreatedAt;
         type Uri;
+        type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type CreatedAt = Unset;
         type Uri = Unset;
+        type CreatedAt = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
+        type Name = St::Name;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Uri = St::Uri;
         type CreatedAt = St::CreatedAt;
-        type Uri = Set<members::uri>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -6714,9 +6714,9 @@ impl<S: BosStr, St: game_detail_view_state::State> GameDetailViewBuilder<S, St>
 impl<S: BosStr, St> GameDetailViewBuilder<S, St>
 where
     St: game_detail_view_state::State,
-    St::Name: game_detail_view_state::IsSet,
-    St::CreatedAt: game_detail_view_state::IsSet,
     St::Uri: game_detail_view_state::IsSet,
+    St::CreatedAt: game_detail_view_state::IsSet,
+    St::Name: game_detail_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GameDetailView<S> {
@@ -6916,37 +6916,37 @@ pub mod game_summary_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Uri;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Uri = St::Uri;
+        type Name = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Name = St::Name;
         type Uri = Set<members::uri>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Uri = St::Uri;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -7101,8 +7101,8 @@ where
 impl<S: BosStr, St> GameSummaryViewBuilder<S, St>
 where
     St: game_summary_view_state::State,
-    St::Name: game_summary_view_state::IsSet,
     St::Uri: game_summary_view_state::IsSet,
+    St::Name: game_summary_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GameSummaryView<S> {
@@ -8203,37 +8203,37 @@ pub mod platform_features_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Platform;
         type Features;
+        type Platform;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Platform = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `platform` field to Set
-    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlatform<St> {}
-    impl<St: State> State for SetPlatform<St> {
-        type Platform = Set<members::platform>;
-        type Features = St::Features;
+        type Platform = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Platform = St::Platform;
         type Features = Set<members::features>;
+        type Platform = St::Platform;
+    }
+    ///State transition - sets the `platform` field to Set
+    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlatform<St> {}
+    impl<St: State> State for SetPlatform<St> {
+        type Features = St::Features;
+        type Platform = Set<members::platform>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `platform` field
-        pub struct platform(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `platform` field
+        pub struct platform(());
     }
 }
 
@@ -8303,8 +8303,8 @@ where
 impl<S: BosStr, St> PlatformFeaturesBuilder<S, St>
 where
     St: platform_features_state::State,
-    St::Platform: platform_features_state::IsSet,
     St::Features: platform_features_state::IsSet,
+    St::Platform: platform_features_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlatformFeatures<S> {
@@ -8540,51 +8540,51 @@ pub mod profile_summary_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ProfileType;
         type Uri;
         type Did;
+        type ProfileType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ProfileType = Unset;
         type Uri = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `profile_type` field to Set
-    pub struct SetProfileType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetProfileType<St> {}
-    impl<St: State> State for SetProfileType<St> {
-        type ProfileType = Set<members::profile_type>;
-        type Uri = St::Uri;
-        type Did = St::Did;
+        type ProfileType = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type ProfileType = St::ProfileType;
         type Uri = Set<members::uri>;
         type Did = St::Did;
+        type ProfileType = St::ProfileType;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type ProfileType = St::ProfileType;
         type Uri = St::Uri;
         type Did = Set<members::did>;
+        type ProfileType = St::ProfileType;
+    }
+    ///State transition - sets the `profile_type` field to Set
+    pub struct SetProfileType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetProfileType<St> {}
+    impl<St: State> State for SetProfileType<St> {
+        type Uri = St::Uri;
+        type Did = St::Did;
+        type ProfileType = Set<members::profile_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `profile_type` field
-        pub struct profile_type(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `profile_type` field
+        pub struct profile_type(());
     }
 }
 
@@ -8705,9 +8705,9 @@ where
 impl<S: BosStr, St> ProfileSummaryViewBuilder<S, St>
 where
     St: profile_summary_view_state::State,
-    St::ProfileType: profile_summary_view_state::IsSet,
     St::Uri: profile_summary_view_state::IsSet,
     St::Did: profile_summary_view_state::IsSet,
+    St::ProfileType: profile_summary_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileSummaryView<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/credit.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/credit.rs
index 73f1c35c..a9881537 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/credit.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/credit.rs
@@ -131,37 +131,37 @@ pub mod credit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Game;
         type Credits;
+        type Game;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Game = Unset;
         type Credits = Unset;
-    }
-    ///State transition - sets the `game` field to Set
-    pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGame<St> {}
-    impl<St: State> State for SetGame<St> {
-        type Game = Set<members::game>;
-        type Credits = St::Credits;
+        type Game = Unset;
     }
     ///State transition - sets the `credits` field to Set
     pub struct SetCredits<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCredits<St> {}
     impl<St: State> State for SetCredits<St> {
-        type Game = St::Game;
         type Credits = Set<members::credits>;
+        type Game = St::Game;
+    }
+    ///State transition - sets the `game` field to Set
+    pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGame<St> {}
+    impl<St: State> State for SetGame<St> {
+        type Credits = St::Credits;
+        type Game = Set<members::game>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `game` field
-        pub struct game(());
         ///Marker type for the `credits` field
         pub struct credits(());
+        ///Marker type for the `game` field
+        pub struct game(());
     }
 }
 
@@ -262,8 +262,8 @@ where
 impl<S: BosStr, St> CreditBuilder<S, St>
 where
     St: credit_state::State,
-    St::Game: credit_state::IsSet,
     St::Credits: credit_state::IsSet,
+    St::Game: credit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Credit<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/game.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/game.rs
index 89f664c1..bcad9925 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/game.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/game.rs
@@ -395,51 +395,51 @@ pub mod game_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Game;
         type Platform;
+        type Game;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Game = Unset;
         type Platform = Unset;
+        type Game = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `platform` field to Set
+    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlatform<St> {}
+    impl<St: State> State for SetPlatform<St> {
+        type Platform = Set<members::platform>;
         type Game = St::Game;
-        type Platform = St::Platform;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `game` field to Set
     pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGame<St> {}
     impl<St: State> State for SetGame<St> {
-        type CreatedAt = St::CreatedAt;
-        type Game = Set<members::game>;
         type Platform = St::Platform;
-    }
-    ///State transition - sets the `platform` field to Set
-    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlatform<St> {}
-    impl<St: State> State for SetPlatform<St> {
+        type Game = Set<members::game>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Platform = St::Platform;
         type Game = St::Game;
-        type Platform = Set<members::platform>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `game` field
-        pub struct game(());
         ///Marker type for the `platform` field
         pub struct platform(());
+        ///Marker type for the `game` field
+        pub struct game(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -552,9 +552,9 @@ impl<S: BosStr, St: game_state::State> GameBuilder<S, St> {
 impl<S: BosStr, St> GameBuilder<S, St>
 where
     St: game_state::State,
-    St::CreatedAt: game_state::IsSet,
-    St::Game: game_state::IsSet,
     St::Platform: game_state::IsSet,
+    St::Game: game_state::IsSet,
+    St::CreatedAt: game_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Game<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/profile.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/profile.rs
index 2c3219c2..b37127e5 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/profile.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/actor/profile.rs
@@ -200,37 +200,37 @@ pub mod profile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type DisplayName;
         type CreatedAt;
+        type DisplayName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type DisplayName = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
-        type DisplayName = Set<members::display_name>;
-        type CreatedAt = St::CreatedAt;
+        type DisplayName = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type DisplayName = St::DisplayName;
         type CreatedAt = Set<members::created_at>;
+        type DisplayName = St::DisplayName;
+    }
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
+        type CreatedAt = St::CreatedAt;
+        type DisplayName = Set<members::display_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
     }
 }
 
@@ -376,8 +376,8 @@ impl<S: BosStr, St: profile_state::State> ProfileBuilder<S, St> {
 impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
-    St::DisplayName: profile_state::IsSet,
     St::CreatedAt: profile_state::IsSet,
+    St::DisplayName: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/claim.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/claim.rs
index 26aa2a10..287d0523 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/claim.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/claim.rs
@@ -223,37 +223,37 @@ pub mod claim_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type CreatedAt;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type CreatedAt = St::CreatedAt;
+        type Type = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type CreatedAt = St::CreatedAt;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -382,8 +382,8 @@ where
 impl<S: BosStr, St> ClaimBuilder<S, St>
 where
     St: claim_state::State,
-    St::Type: claim_state::IsSet,
     St::CreatedAt: claim_state::IsSet,
+    St::Type: claim_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Claim<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/claim_review.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/claim_review.rs
index a6e6b6c0..a4edbb9b 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/claim_review.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/claim_review.rs
@@ -209,67 +209,67 @@ pub mod claim_review_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Status;
         type ReviewedBy;
         type Claim;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Status = Unset;
         type ReviewedBy = Unset;
         type Claim = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Status = St::Status;
-        type ReviewedBy = St::ReviewedBy;
-        type Claim = St::Claim;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type CreatedAt = St::CreatedAt;
         type Status = Set<members::status>;
         type ReviewedBy = St::ReviewedBy;
         type Claim = St::Claim;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `reviewed_by` field to Set
     pub struct SetReviewedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReviewedBy<St> {}
     impl<St: State> State for SetReviewedBy<St> {
-        type CreatedAt = St::CreatedAt;
         type Status = St::Status;
         type ReviewedBy = Set<members::reviewed_by>;
         type Claim = St::Claim;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `claim` field to Set
     pub struct SetClaim<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClaim<St> {}
     impl<St: State> State for SetClaim<St> {
-        type CreatedAt = St::CreatedAt;
         type Status = St::Status;
         type ReviewedBy = St::ReviewedBy;
         type Claim = Set<members::claim>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Status = St::Status;
+        type ReviewedBy = St::ReviewedBy;
+        type Claim = St::Claim;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `status` field
         pub struct status(());
         ///Marker type for the `reviewed_by` field
         pub struct reviewed_by(());
         ///Marker type for the `claim` field
         pub struct claim(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -410,10 +410,10 @@ where
 impl<S: BosStr, St> ClaimReviewBuilder<S, St>
 where
     St: claim_review_state::State,
-    St::CreatedAt: claim_review_state::IsSet,
     St::Status: claim_review_state::IsSet,
     St::ReviewedBy: claim_review_state::IsSet,
     St::Claim: claim_review_state::IsSet,
+    St::CreatedAt: claim_review_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ClaimReview<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/collection.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/collection.rs
index 1307a839..85957a5a 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/collection.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/collection.rs
@@ -208,37 +208,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -395,8 +395,8 @@ impl<S: BosStr, St: collection_state::State> CollectionBuilder<S, St> {
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::CreatedAt: collection_state::IsSet,
     St::Name: collection_state::IsSet,
+    St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/engine.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/engine.rs
index 4d11a673..daaaf825 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/engine.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/engine.rs
@@ -124,37 +124,37 @@ pub mod engine_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -297,8 +297,8 @@ impl<S: BosStr, St: engine_state::State> EngineBuilder<S, St> {
 impl<S: BosStr, St> EngineBuilder<S, St>
 where
     St: engine_state::State,
-    St::CreatedAt: engine_state::IsSet,
     St::Name: engine_state::IsSet,
+    St::CreatedAt: engine_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Engine<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/feed/generator.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/feed/generator.rs
index de801421..955c093c 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/feed/generator.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/feed/generator.rs
@@ -206,51 +206,51 @@ pub mod generator_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type DisplayName;
         type CreatedAt;
         type Did;
+        type DisplayName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type DisplayName = Unset;
         type CreatedAt = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
-        type DisplayName = Set<members::display_name>;
-        type CreatedAt = St::CreatedAt;
-        type Did = St::Did;
+        type DisplayName = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type DisplayName = St::DisplayName;
         type CreatedAt = Set<members::created_at>;
         type Did = St::Did;
+        type DisplayName = St::DisplayName;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type DisplayName = St::DisplayName;
         type CreatedAt = St::CreatedAt;
         type Did = Set<members::did>;
+        type DisplayName = St::DisplayName;
+    }
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Did = St::Did;
+        type DisplayName = Set<members::display_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `display_name` field
-        pub struct display_name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `display_name` field
+        pub struct display_name(());
     }
 }
 
@@ -385,9 +385,9 @@ where
 impl<S: BosStr, St> GeneratorBuilder<S, St>
 where
     St: generator_state::State,
-    St::DisplayName: generator_state::IsSet,
     St::CreatedAt: generator_state::IsSet,
     St::Did: generator_state::IsSet,
+    St::DisplayName: generator_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Generator<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/get_claim.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/get_claim.rs
index 9eca26a2..df4a7c69 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/get_claim.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/get_claim.rs
@@ -301,85 +301,85 @@ pub mod claim_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
-        type Cid;
         type ClaimantDid;
-        type Type;
+        type Cid;
+        type Uri;
         type CreatedAt;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
-        type Cid = Unset;
         type ClaimantDid = Unset;
-        type Type = Unset;
+        type Cid = Unset;
+        type Uri = Unset;
         type CreatedAt = Unset;
+        type Type = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
+    ///State transition - sets the `claimant_did` field to Set
+    pub struct SetClaimantDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetClaimantDid<St> {}
+    impl<St: State> State for SetClaimantDid<St> {
+        type ClaimantDid = Set<members::claimant_did>;
         type Cid = St::Cid;
-        type ClaimantDid = St::ClaimantDid;
-        type Type = St::Type;
+        type Uri = St::Uri;
         type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
-        type Cid = Set<members::cid>;
         type ClaimantDid = St::ClaimantDid;
-        type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `claimant_did` field to Set
-    pub struct SetClaimantDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetClaimantDid<St> {}
-    impl<St: State> State for SetClaimantDid<St> {
+        type Cid = Set<members::cid>;
         type Uri = St::Uri;
-        type Cid = St::Cid;
-        type ClaimantDid = Set<members::claimant_did>;
-        type Type = St::Type;
         type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
     }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Uri = St::Uri;
-        type Cid = St::Cid;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
         type ClaimantDid = St::ClaimantDid;
-        type Type = Set<members::r#type>;
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
         type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Uri = St::Uri;
-        type Cid = St::Cid;
         type ClaimantDid = St::ClaimantDid;
-        type Type = St::Type;
+        type Cid = St::Cid;
+        type Uri = St::Uri;
         type CreatedAt = Set<members::created_at>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type ClaimantDid = St::ClaimantDid;
+        type Cid = St::Cid;
+        type Uri = St::Uri;
+        type CreatedAt = St::CreatedAt;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `claimant_did` field
         pub struct claimant_did(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -582,11 +582,11 @@ where
 impl<S: BosStr, St> ClaimViewBuilder<S, St>
 where
     St: claim_view_state::State,
-    St::Uri: claim_view_state::IsSet,
-    St::Cid: claim_view_state::IsSet,
     St::ClaimantDid: claim_view_state::IsSet,
-    St::Type: claim_view_state::IsSet,
+    St::Cid: claim_view_state::IsSet,
+    St::Uri: claim_view_state::IsSet,
     St::CreatedAt: claim_view_state::IsSet,
+    St::Type: claim_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ClaimView<S> {
@@ -903,67 +903,67 @@ pub mod review_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type ReviewedBy;
-        type Uri;
         type CreatedAt;
+        type Status;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type ReviewedBy = Unset;
-        type Uri = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type ReviewedBy = St::ReviewedBy;
-        type Uri = St::Uri;
-        type CreatedAt = St::CreatedAt;
+        type Status = Unset;
+        type Uri = Unset;
     }
     ///State transition - sets the `reviewed_by` field to Set
     pub struct SetReviewedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReviewedBy<St> {}
     impl<St: State> State for SetReviewedBy<St> {
-        type Status = St::Status;
         type ReviewedBy = Set<members::reviewed_by>;
-        type Uri = St::Uri;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Status = St::Status;
-        type ReviewedBy = St::ReviewedBy;
-        type Uri = Set<members::uri>;
-        type CreatedAt = St::CreatedAt;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type ReviewedBy = St::ReviewedBy;
+        type CreatedAt = Set<members::created_at>;
         type Status = St::Status;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
         type ReviewedBy = St::ReviewedBy;
+        type CreatedAt = St::CreatedAt;
+        type Status = Set<members::status>;
         type Uri = St::Uri;
-        type CreatedAt = Set<members::created_at>;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type ReviewedBy = St::ReviewedBy;
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `reviewed_by` field
         pub struct reviewed_by(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -1104,10 +1104,10 @@ where
 impl<S: BosStr, St> ReviewViewBuilder<S, St>
 where
     St: review_view_state::State,
-    St::Status: review_view_state::IsSet,
     St::ReviewedBy: review_view_state::IsSet,
-    St::Uri: review_view_state::IsSet,
     St::CreatedAt: review_view_state::IsSet,
+    St::Status: review_view_state::IsSet,
+    St::Uri: review_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReviewView<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/get_reviews.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/get_reviews.rs
index 0b3bda34..bfca8b00 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/get_reviews.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/get_reviews.rs
@@ -261,67 +261,67 @@ pub mod popfeed_review_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Rating;
         type Uri;
         type Did;
+        type CreatedAt;
+        type Rating;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Rating = Unset;
         type Uri = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Rating = St::Rating;
-        type Uri = St::Uri;
-        type Did = St::Did;
-    }
-    ///State transition - sets the `rating` field to Set
-    pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRating<St> {}
-    impl<St: State> State for SetRating<St> {
-        type CreatedAt = St::CreatedAt;
-        type Rating = Set<members::rating>;
-        type Uri = St::Uri;
-        type Did = St::Did;
+        type CreatedAt = Unset;
+        type Rating = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type CreatedAt = St::CreatedAt;
-        type Rating = St::Rating;
         type Uri = Set<members::uri>;
         type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
+        type Rating = St::Rating;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
+        type Uri = St::Uri;
+        type Did = Set<members::did>;
         type CreatedAt = St::CreatedAt;
         type Rating = St::Rating;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Uri = St::Uri;
-        type Did = Set<members::did>;
+        type Did = St::Did;
+        type CreatedAt = Set<members::created_at>;
+        type Rating = St::Rating;
+    }
+    ///State transition - sets the `rating` field to Set
+    pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRating<St> {}
+    impl<St: State> State for SetRating<St> {
+        type Uri = St::Uri;
+        type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
+        type Rating = Set<members::rating>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `rating` field
-        pub struct rating(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `rating` field
+        pub struct rating(());
     }
 }
 
@@ -504,10 +504,10 @@ where
 impl<S: BosStr, St> PopfeedReviewBuilder<S, St>
 where
     St: popfeed_review_state::State,
-    St::CreatedAt: popfeed_review_state::IsSet,
-    St::Rating: popfeed_review_state::IsSet,
     St::Uri: popfeed_review_state::IsSet,
     St::Did: popfeed_review_state::IsSet,
+    St::CreatedAt: popfeed_review_state::IsSet,
+    St::Rating: popfeed_review_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PopfeedReview<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/migrate_claim.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/migrate_claim.rs
index f5cfa4af..81d5eb59 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/migrate_claim.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/migrate_claim.rs
@@ -329,37 +329,37 @@ pub mod migration_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type GameUri;
         type Status;
+        type GameUri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type GameUri = Unset;
         type Status = Unset;
-    }
-    ///State transition - sets the `game_uri` field to Set
-    pub struct SetGameUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGameUri<St> {}
-    impl<St: State> State for SetGameUri<St> {
-        type GameUri = Set<members::game_uri>;
-        type Status = St::Status;
+        type GameUri = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type GameUri = St::GameUri;
         type Status = Set<members::status>;
+        type GameUri = St::GameUri;
+    }
+    ///State transition - sets the `game_uri` field to Set
+    pub struct SetGameUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGameUri<St> {}
+    impl<St: State> State for SetGameUri<St> {
+        type Status = St::Status;
+        type GameUri = Set<members::game_uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `game_uri` field
-        pub struct game_uri(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `game_uri` field
+        pub struct game_uri(());
     }
 }
 
@@ -460,8 +460,8 @@ where
 impl<S: BosStr, St> MigrationResultBuilder<S, St>
 where
     St: migration_result_state::State,
-    St::GameUri: migration_result_state::IsSet,
     St::Status: migration_result_state::IsSet,
+    St::GameUri: migration_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MigrationResult<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/org/credit.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/org/credit.rs
index 74493605..d359014e 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/org/credit.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/org/credit.rs
@@ -131,49 +131,49 @@ pub mod credit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Game;
         type Roles;
+        type Game;
         type Org;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Game = Unset;
         type Roles = Unset;
+        type Game = Unset;
         type Org = Unset;
     }
-    ///State transition - sets the `game` field to Set
-    pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGame<St> {}
-    impl<St: State> State for SetGame<St> {
-        type Game = Set<members::game>;
-        type Roles = St::Roles;
-        type Org = St::Org;
-    }
     ///State transition - sets the `roles` field to Set
     pub struct SetRoles<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoles<St> {}
     impl<St: State> State for SetRoles<St> {
-        type Game = St::Game;
         type Roles = Set<members::roles>;
+        type Game = St::Game;
+        type Org = St::Org;
+    }
+    ///State transition - sets the `game` field to Set
+    pub struct SetGame<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGame<St> {}
+    impl<St: State> State for SetGame<St> {
+        type Roles = St::Roles;
+        type Game = Set<members::game>;
         type Org = St::Org;
     }
     ///State transition - sets the `org` field to Set
     pub struct SetOrg<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOrg<St> {}
     impl<St: State> State for SetOrg<St> {
-        type Game = St::Game;
         type Roles = St::Roles;
+        type Game = St::Game;
         type Org = Set<members::org>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `game` field
-        pub struct game(());
         ///Marker type for the `roles` field
         pub struct roles(());
+        ///Marker type for the `game` field
+        pub struct game(());
         ///Marker type for the `org` field
         pub struct org(());
     }
@@ -296,8 +296,8 @@ where
 impl<S: BosStr, St> CreditBuilder<S, St>
 where
     St: credit_state::State,
-    St::Game: credit_state::IsSet,
     St::Roles: credit_state::IsSet,
+    St::Game: credit_state::IsSet,
     St::Org: credit_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/platform_family.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/platform_family.rs
index 3dfdf99b..ce691973 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/platform_family.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/platform_family.rs
@@ -114,37 +114,37 @@ pub mod platform_family_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -227,8 +227,8 @@ where
 impl<S: BosStr, St> PlatformFamilyBuilder<S, St>
 where
     St: platform_family_state::State,
-    St::Name: platform_family_state::IsSet,
     St::CreatedAt: platform_family_state::IsSet,
+    St::Name: platform_family_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PlatformFamily<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/redirect.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/redirect.rs
index 81fb5aab..c8ec9bac 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/redirect.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/redirect.rs
@@ -114,67 +114,67 @@ pub mod redirect_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Collection;
-        type SourceUri;
         type TargetUri;
-        type CreatedAt;
+        type SourceUri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Collection = Unset;
-        type SourceUri = Unset;
         type TargetUri = Unset;
-        type CreatedAt = Unset;
+        type SourceUri = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Collection = St::Collection;
+        type TargetUri = St::TargetUri;
+        type SourceUri = St::SourceUri;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
-        type SourceUri = St::SourceUri;
-        type TargetUri = St::TargetUri;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `source_uri` field to Set
-    pub struct SetSourceUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSourceUri<St> {}
-    impl<St: State> State for SetSourceUri<St> {
-        type Collection = St::Collection;
-        type SourceUri = Set<members::source_uri>;
+        type Collection = Set<members::collection>;
         type TargetUri = St::TargetUri;
-        type CreatedAt = St::CreatedAt;
+        type SourceUri = St::SourceUri;
     }
     ///State transition - sets the `target_uri` field to Set
     pub struct SetTargetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTargetUri<St> {}
     impl<St: State> State for SetTargetUri<St> {
+        type CreatedAt = St::CreatedAt;
         type Collection = St::Collection;
-        type SourceUri = St::SourceUri;
         type TargetUri = Set<members::target_uri>;
-        type CreatedAt = St::CreatedAt;
+        type SourceUri = St::SourceUri;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `source_uri` field to Set
+    pub struct SetSourceUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSourceUri<St> {}
+    impl<St: State> State for SetSourceUri<St> {
+        type CreatedAt = St::CreatedAt;
         type Collection = St::Collection;
-        type SourceUri = St::SourceUri;
         type TargetUri = St::TargetUri;
-        type CreatedAt = Set<members::created_at>;
+        type SourceUri = Set<members::source_uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `collection` field
         pub struct collection(());
-        ///Marker type for the `source_uri` field
-        pub struct source_uri(());
         ///Marker type for the `target_uri` field
         pub struct target_uri(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `source_uri` field
+        pub struct source_uri(());
     }
 }
 
@@ -282,10 +282,10 @@ where
 impl<S: BosStr, St> RedirectBuilder<S, St>
 where
     St: redirect_state::State,
+    St::CreatedAt: redirect_state::IsSet,
     St::Collection: redirect_state::IsSet,
-    St::SourceUri: redirect_state::IsSet,
     St::TargetUri: redirect_state::IsSet,
-    St::CreatedAt: redirect_state::IsSet,
+    St::SourceUri: redirect_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Redirect<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/review_claim.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/review_claim.rs
index 63bf913a..4f1912e2 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/review_claim.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/review_claim.rs
@@ -156,37 +156,37 @@ pub mod review_claim_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Claim;
         type Status;
+        type Claim;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Claim = Unset;
         type Status = Unset;
-    }
-    ///State transition - sets the `claim` field to Set
-    pub struct SetClaim<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetClaim<St> {}
-    impl<St: State> State for SetClaim<St> {
-        type Claim = Set<members::claim>;
-        type Status = St::Status;
+        type Claim = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type Claim = St::Claim;
         type Status = Set<members::status>;
+        type Claim = St::Claim;
+    }
+    ///State transition - sets the `claim` field to Set
+    pub struct SetClaim<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetClaim<St> {}
+    impl<St: State> State for SetClaim<St> {
+        type Status = St::Status;
+        type Claim = Set<members::claim>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `claim` field
-        pub struct claim(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `claim` field
+        pub struct claim(());
     }
 }
 
@@ -287,8 +287,8 @@ where
 impl<S: BosStr, St> ReviewClaimBuilder<S, St>
 where
     St: review_claim_state::State,
-    St::Claim: review_claim_state::IsSet,
     St::Status: review_claim_state::IsSet,
+    St::Claim: review_claim_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReviewClaim<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/richtext/facet.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/richtext/facet.rs
index 131c13e6..5778637a 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/richtext/facet.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/richtext/facet.rs
@@ -1293,37 +1293,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Features;
         type Index;
+        type Features;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Features = Unset;
         type Index = Unset;
-    }
-    ///State transition - sets the `features` field to Set
-    pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFeatures<St> {}
-    impl<St: State> State for SetFeatures<St> {
-        type Features = Set<members::features>;
-        type Index = St::Index;
+        type Features = Unset;
     }
     ///State transition - sets the `index` field to Set
     pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndex<St> {}
     impl<St: State> State for SetIndex<St> {
-        type Features = St::Features;
         type Index = Set<members::index>;
+        type Features = St::Features;
+    }
+    ///State transition - sets the `features` field to Set
+    pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFeatures<St> {}
+    impl<St: State> State for SetFeatures<St> {
+        type Index = St::Index;
+        type Features = Set<members::features>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `features` field
-        pub struct features(());
         ///Marker type for the `index` field
         pub struct index(());
+        ///Marker type for the `features` field
+        pub struct features(());
     }
 }
 
@@ -1393,8 +1393,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Features: facet_state::IsSet,
     St::Index: facet_state::IsSet,
+    St::Features: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/search_slugs.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/search_slugs.rs
index 789236f7..3e4538db 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/search_slugs.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/search_slugs.rs
@@ -211,37 +211,37 @@ pub mod slug_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Ref;
         type Slug;
+        type Ref;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Ref = Unset;
         type Slug = Unset;
-    }
-    ///State transition - sets the `ref` field to Set
-    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRef<St> {}
-    impl<St: State> State for SetRef<St> {
-        type Ref = Set<members::r#ref>;
-        type Slug = St::Slug;
+        type Ref = Unset;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlug<St> {}
     impl<St: State> State for SetSlug<St> {
-        type Ref = St::Ref;
         type Slug = Set<members::slug>;
+        type Ref = St::Ref;
+    }
+    ///State transition - sets the `ref` field to Set
+    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRef<St> {}
+    impl<St: State> State for SetRef<St> {
+        type Slug = St::Slug;
+        type Ref = Set<members::r#ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `ref` field
-        pub struct r#ref(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `ref` field
+        pub struct r#ref(());
     }
 }
 
@@ -311,8 +311,8 @@ where
 impl<S: BosStr, St> SlugResultBuilder<S, St>
 where
     St: slug_result_state::State,
-    St::Ref: slug_result_state::IsSet,
     St::Slug: slug_result_state::IsSet,
+    St::Ref: slug_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SlugResult<S> {
diff --git a/crates/jacquard-api/src/games_gamesgamesgamesgames/slug.rs b/crates/jacquard-api/src/games_gamesgamesgamesgames/slug.rs
index 00bc7bcb..560a3ebb 100644
--- a/crates/jacquard-api/src/games_gamesgamesgamesgames/slug.rs
+++ b/crates/jacquard-api/src/games_gamesgamesgamesgames/slug.rs
@@ -136,37 +136,37 @@ pub mod slug_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Slug;
         type Ref;
+        type Slug;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Slug = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `slug` field to Set
-    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSlug<St> {}
-    impl<St: State> State for SetSlug<St> {
-        type Slug = Set<members::slug>;
-        type Ref = St::Ref;
+        type Slug = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type Slug = St::Slug;
         type Ref = Set<members::r#ref>;
+        type Slug = St::Slug;
+    }
+    ///State transition - sets the `slug` field to Set
+    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSlug<St> {}
+    impl<St: State> State for SetSlug<St> {
+        type Ref = St::Ref;
+        type Slug = Set<members::slug>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `slug` field
-        pub struct slug(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `slug` field
+        pub struct slug(());
     }
 }
 
@@ -236,8 +236,8 @@ where
 impl<S: BosStr, St> SlugBuilder<S, St>
 where
     St: slug_state::State,
-    St::Slug: slug_state::IsSet,
     St::Ref: slug_state::IsSet,
+    St::Slug: slug_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Slug<S> {
diff --git a/crates/jacquard-api/src/garden_goals/category.rs b/crates/jacquard-api/src/garden_goals/category.rs
index 7525335d..6d6bcc47 100644
--- a/crates/jacquard-api/src/garden_goals/category.rs
+++ b/crates/jacquard-api/src/garden_goals/category.rs
@@ -139,50 +139,50 @@ pub mod category_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CategoryId;
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CategoryId = Unset;
-        type CreatedAt = Unset;
         type Name = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `category_id` field to Set
     pub struct SetCategoryId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCategoryId<St> {}
     impl<St: State> State for SetCategoryId<St> {
         type CategoryId = Set<members::category_id>;
-        type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CategoryId = St::CategoryId;
-        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type CategoryId = St::CategoryId;
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CategoryId = St::CategoryId;
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `category_id` field
         pub struct category_id(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -272,8 +272,8 @@ impl<S: BosStr, St> CategoryBuilder<S, St>
 where
     St: category_state::State,
     St::CategoryId: category_state::IsSet,
-    St::CreatedAt: category_state::IsSet,
     St::Name: category_state::IsSet,
+    St::CreatedAt: category_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Category<S> {
diff --git a/crates/jacquard-api/src/garden_goals/completion.rs b/crates/jacquard-api/src/garden_goals/completion.rs
index 4ba22ba4..a06c6722 100644
--- a/crates/jacquard-api/src/garden_goals/completion.rs
+++ b/crates/jacquard-api/src/garden_goals/completion.rs
@@ -251,85 +251,85 @@ pub mod completion_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type GoalId;
-        type CompletedAt;
         type Day;
-        type Month;
+        type GoalId;
         type Year;
+        type Month;
+        type CompletedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type GoalId = Unset;
-        type CompletedAt = Unset;
         type Day = Unset;
-        type Month = Unset;
+        type GoalId = Unset;
         type Year = Unset;
+        type Month = Unset;
+        type CompletedAt = Unset;
+    }
+    ///State transition - sets the `day` field to Set
+    pub struct SetDay<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDay<St> {}
+    impl<St: State> State for SetDay<St> {
+        type Day = Set<members::day>;
+        type GoalId = St::GoalId;
+        type Year = St::Year;
+        type Month = St::Month;
+        type CompletedAt = St::CompletedAt;
     }
     ///State transition - sets the `goal_id` field to Set
     pub struct SetGoalId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGoalId<St> {}
     impl<St: State> State for SetGoalId<St> {
-        type GoalId = Set<members::goal_id>;
-        type CompletedAt = St::CompletedAt;
         type Day = St::Day;
-        type Month = St::Month;
+        type GoalId = Set<members::goal_id>;
         type Year = St::Year;
-    }
-    ///State transition - sets the `completed_at` field to Set
-    pub struct SetCompletedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCompletedAt<St> {}
-    impl<St: State> State for SetCompletedAt<St> {
-        type GoalId = St::GoalId;
-        type CompletedAt = Set<members::completed_at>;
-        type Day = St::Day;
         type Month = St::Month;
-        type Year = St::Year;
+        type CompletedAt = St::CompletedAt;
     }
-    ///State transition - sets the `day` field to Set
-    pub struct SetDay<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDay<St> {}
-    impl<St: State> State for SetDay<St> {
+    ///State transition - sets the `year` field to Set
+    pub struct SetYear<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetYear<St> {}
+    impl<St: State> State for SetYear<St> {
+        type Day = St::Day;
         type GoalId = St::GoalId;
-        type CompletedAt = St::CompletedAt;
-        type Day = Set<members::day>;
+        type Year = Set<members::year>;
         type Month = St::Month;
-        type Year = St::Year;
+        type CompletedAt = St::CompletedAt;
     }
     ///State transition - sets the `month` field to Set
     pub struct SetMonth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMonth<St> {}
     impl<St: State> State for SetMonth<St> {
-        type GoalId = St::GoalId;
-        type CompletedAt = St::CompletedAt;
         type Day = St::Day;
-        type Month = Set<members::month>;
-        type Year = St::Year;
-    }
-    ///State transition - sets the `year` field to Set
-    pub struct SetYear<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetYear<St> {}
-    impl<St: State> State for SetYear<St> {
         type GoalId = St::GoalId;
+        type Year = St::Year;
+        type Month = Set<members::month>;
         type CompletedAt = St::CompletedAt;
+    }
+    ///State transition - sets the `completed_at` field to Set
+    pub struct SetCompletedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCompletedAt<St> {}
+    impl<St: State> State for SetCompletedAt<St> {
         type Day = St::Day;
+        type GoalId = St::GoalId;
+        type Year = St::Year;
         type Month = St::Month;
-        type Year = Set<members::year>;
+        type CompletedAt = Set<members::completed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `goal_id` field
-        pub struct goal_id(());
-        ///Marker type for the `completed_at` field
-        pub struct completed_at(());
         ///Marker type for the `day` field
         pub struct day(());
-        ///Marker type for the `month` field
-        pub struct month(());
+        ///Marker type for the `goal_id` field
+        pub struct goal_id(());
         ///Marker type for the `year` field
         pub struct year(());
+        ///Marker type for the `month` field
+        pub struct month(());
+        ///Marker type for the `completed_at` field
+        pub struct completed_at(());
     }
 }
 
@@ -518,11 +518,11 @@ where
 impl<S: BosStr, St> CompletionBuilder<S, St>
 where
     St: completion_state::State,
-    St::GoalId: completion_state::IsSet,
-    St::CompletedAt: completion_state::IsSet,
     St::Day: completion_state::IsSet,
-    St::Month: completion_state::IsSet,
+    St::GoalId: completion_state::IsSet,
     St::Year: completion_state::IsSet,
+    St::Month: completion_state::IsSet,
+    St::CompletedAt: completion_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Completion<S> {
diff --git a/crates/jacquard-api/src/garden_goals/completion_details.rs b/crates/jacquard-api/src/garden_goals/completion_details.rs
index 3e0af12a..c753e59c 100644
--- a/crates/jacquard-api/src/garden_goals/completion_details.rs
+++ b/crates/jacquard-api/src/garden_goals/completion_details.rs
@@ -254,9 +254,9 @@ pub mod completion_details_state {
     pub trait State: sealed::Sealed {
         type GoalId;
         type Year;
+        type UpdatedAt;
         type Month;
         type Day;
-        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -264,9 +264,9 @@ pub mod completion_details_state {
     impl State for Empty {
         type GoalId = Unset;
         type Year = Unset;
+        type UpdatedAt = Unset;
         type Month = Unset;
         type Day = Unset;
-        type UpdatedAt = Unset;
     }
     ///State transition - sets the `goal_id` field to Set
     pub struct SetGoalId<St: State = Empty>(PhantomData<fn() -> St>);
@@ -274,9 +274,9 @@ pub mod completion_details_state {
     impl<St: State> State for SetGoalId<St> {
         type GoalId = Set<members::goal_id>;
         type Year = St::Year;
+        type UpdatedAt = St::UpdatedAt;
         type Month = St::Month;
         type Day = St::Day;
-        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `year` field to Set
     pub struct SetYear<St: State = Empty>(PhantomData<fn() -> St>);
@@ -284,9 +284,19 @@ pub mod completion_details_state {
     impl<St: State> State for SetYear<St> {
         type GoalId = St::GoalId;
         type Year = Set<members::year>;
+        type UpdatedAt = St::UpdatedAt;
+        type Month = St::Month;
+        type Day = St::Day;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type GoalId = St::GoalId;
+        type Year = St::Year;
+        type UpdatedAt = Set<members::updated_at>;
         type Month = St::Month;
         type Day = St::Day;
-        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `month` field to Set
     pub struct SetMonth<St: State = Empty>(PhantomData<fn() -> St>);
@@ -294,9 +304,9 @@ pub mod completion_details_state {
     impl<St: State> State for SetMonth<St> {
         type GoalId = St::GoalId;
         type Year = St::Year;
+        type UpdatedAt = St::UpdatedAt;
         type Month = Set<members::month>;
         type Day = St::Day;
-        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `day` field to Set
     pub struct SetDay<St: State = Empty>(PhantomData<fn() -> St>);
@@ -304,19 +314,9 @@ pub mod completion_details_state {
     impl<St: State> State for SetDay<St> {
         type GoalId = St::GoalId;
         type Year = St::Year;
-        type Month = St::Month;
-        type Day = Set<members::day>;
         type UpdatedAt = St::UpdatedAt;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type GoalId = St::GoalId;
-        type Year = St::Year;
         type Month = St::Month;
-        type Day = St::Day;
-        type UpdatedAt = Set<members::updated_at>;
+        type Day = Set<members::day>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -325,12 +325,12 @@ pub mod completion_details_state {
         pub struct goal_id(());
         ///Marker type for the `year` field
         pub struct year(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
         ///Marker type for the `month` field
         pub struct month(());
         ///Marker type for the `day` field
         pub struct day(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
     }
 }
 
@@ -521,9 +521,9 @@ where
     St: completion_details_state::State,
     St::GoalId: completion_details_state::IsSet,
     St::Year: completion_details_state::IsSet,
+    St::UpdatedAt: completion_details_state::IsSet,
     St::Month: completion_details_state::IsSet,
     St::Day: completion_details_state::IsSet,
-    St::UpdatedAt: completion_details_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CompletionDetails<S> {
diff --git a/crates/jacquard-api/src/garden_goals/goal.rs b/crates/jacquard-api/src/garden_goals/goal.rs
index f9180c6a..ebc3aa7f 100644
--- a/crates/jacquard-api/src/garden_goals/goal.rs
+++ b/crates/jacquard-api/src/garden_goals/goal.rs
@@ -320,8 +320,8 @@ pub mod goal_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type GoalId;
-        type Year;
         type Name;
+        type Year;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
@@ -329,8 +329,8 @@ pub mod goal_state {
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type GoalId = Unset;
-        type Year = Unset;
         type Name = Unset;
+        type Year = Unset;
         type CreatedAt = Unset;
     }
     ///State transition - sets the `goal_id` field to Set
@@ -338,17 +338,8 @@ pub mod goal_state {
     impl<St: State> sealed::Sealed for SetGoalId<St> {}
     impl<St: State> State for SetGoalId<St> {
         type GoalId = Set<members::goal_id>;
-        type Year = St::Year;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `year` field to Set
-    pub struct SetYear<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetYear<St> {}
-    impl<St: State> State for SetYear<St> {
-        type GoalId = St::GoalId;
-        type Year = Set<members::year>;
         type Name = St::Name;
+        type Year = St::Year;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `name` field to Set
@@ -356,8 +347,17 @@ pub mod goal_state {
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type GoalId = St::GoalId;
-        type Year = St::Year;
         type Name = Set<members::name>;
+        type Year = St::Year;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `year` field to Set
+    pub struct SetYear<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetYear<St> {}
+    impl<St: State> State for SetYear<St> {
+        type GoalId = St::GoalId;
+        type Name = St::Name;
+        type Year = Set<members::year>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
@@ -365,8 +365,8 @@ pub mod goal_state {
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type GoalId = St::GoalId;
-        type Year = St::Year;
         type Name = St::Name;
+        type Year = St::Year;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
@@ -374,10 +374,10 @@ pub mod goal_state {
     pub mod members {
         ///Marker type for the `goal_id` field
         pub struct goal_id(());
-        ///Marker type for the `year` field
-        pub struct year(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `year` field
+        pub struct year(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -663,8 +663,8 @@ impl<S: BosStr, St> GoalBuilder<S, St>
 where
     St: goal_state::State,
     St::GoalId: goal_state::IsSet,
-    St::Year: goal_state::IsSet,
     St::Name: goal_state::IsSet,
+    St::Year: goal_state::IsSet,
     St::CreatedAt: goal_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/garden_lexicon/documentation.rs b/crates/jacquard-api/src/garden_lexicon/documentation.rs
index 860c3f2c..61eacd25 100644
--- a/crates/jacquard-api/src/garden_lexicon/documentation.rs
+++ b/crates/jacquard-api/src/garden_lexicon/documentation.rs
@@ -613,37 +613,37 @@ pub mod documentation_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Lexicon;
         type CreatedAt;
+        type Lexicon;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Lexicon = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `lexicon` field to Set
-    pub struct SetLexicon<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLexicon<St> {}
-    impl<St: State> State for SetLexicon<St> {
-        type Lexicon = Set<members::lexicon>;
-        type CreatedAt = St::CreatedAt;
+        type Lexicon = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Lexicon = St::Lexicon;
         type CreatedAt = Set<members::created_at>;
+        type Lexicon = St::Lexicon;
+    }
+    ///State transition - sets the `lexicon` field to Set
+    pub struct SetLexicon<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLexicon<St> {}
+    impl<St: State> State for SetLexicon<St> {
+        type CreatedAt = St::CreatedAt;
+        type Lexicon = Set<members::lexicon>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `lexicon` field
-        pub struct lexicon(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `lexicon` field
+        pub struct lexicon(());
     }
 }
 
@@ -756,8 +756,8 @@ where
 impl<S: BosStr, St> DocumentationBuilder<S, St>
 where
     St: documentation_state::State,
-    St::Lexicon: documentation_state::IsSet,
     St::CreatedAt: documentation_state::IsSet,
+    St::Lexicon: documentation_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Documentation<S> {
diff --git a/crates/jacquard-api/src/garden_lexicon/example.rs b/crates/jacquard-api/src/garden_lexicon/example.rs
index 2f1fdcd9..8ee10dd4 100644
--- a/crates/jacquard-api/src/garden_lexicon/example.rs
+++ b/crates/jacquard-api/src/garden_lexicon/example.rs
@@ -119,51 +119,51 @@ pub mod example_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Lexicon;
         type Value;
         type CreatedAt;
-        type Lexicon;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Lexicon = Unset;
         type Value = Unset;
         type CreatedAt = Unset;
-        type Lexicon = Unset;
+    }
+    ///State transition - sets the `lexicon` field to Set
+    pub struct SetLexicon<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLexicon<St> {}
+    impl<St: State> State for SetLexicon<St> {
+        type Lexicon = Set<members::lexicon>;
+        type Value = St::Value;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
+        type Lexicon = St::Lexicon;
         type Value = Set<members::value>;
         type CreatedAt = St::CreatedAt;
-        type Lexicon = St::Lexicon;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Value = St::Value;
-        type CreatedAt = Set<members::created_at>;
         type Lexicon = St::Lexicon;
-    }
-    ///State transition - sets the `lexicon` field to Set
-    pub struct SetLexicon<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLexicon<St> {}
-    impl<St: State> State for SetLexicon<St> {
         type Value = St::Value;
-        type CreatedAt = St::CreatedAt;
-        type Lexicon = Set<members::lexicon>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `lexicon` field
+        pub struct lexicon(());
         ///Marker type for the `value` field
         pub struct value(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `lexicon` field
-        pub struct lexicon(());
     }
 }
 
@@ -265,9 +265,9 @@ where
 impl<S: BosStr, St> ExampleBuilder<S, St>
 where
     St: example_state::State,
+    St::Lexicon: example_state::IsSet,
     St::Value: example_state::IsSet,
     St::CreatedAt: example_state::IsSet,
-    St::Lexicon: example_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Example<S> {
diff --git a/crates/jacquard-api/src/garden_lexicon/exultant_zebra/app.rs b/crates/jacquard-api/src/garden_lexicon/exultant_zebra/app.rs
index 972b22f0..09ba6df2 100644
--- a/crates/jacquard-api/src/garden_lexicon/exultant_zebra/app.rs
+++ b/crates/jacquard-api/src/garden_lexicon/exultant_zebra/app.rs
@@ -118,37 +118,37 @@ pub mod app_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Distributions;
         type Name;
+        type Distributions;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Distributions = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `distributions` field to Set
-    pub struct SetDistributions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDistributions<St> {}
-    impl<St: State> State for SetDistributions<St> {
-        type Distributions = Set<members::distributions>;
-        type Name = St::Name;
+        type Distributions = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Distributions = St::Distributions;
         type Name = Set<members::name>;
+        type Distributions = St::Distributions;
+    }
+    ///State transition - sets the `distributions` field to Set
+    pub struct SetDistributions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDistributions<St> {}
+    impl<St: State> State for SetDistributions<St> {
+        type Name = St::Name;
+        type Distributions = Set<members::distributions>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `distributions` field
-        pub struct distributions(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `distributions` field
+        pub struct distributions(());
     }
 }
 
@@ -228,8 +228,8 @@ where
 impl<S: BosStr, St> AppBuilder<S, St>
 where
     St: app_state::State,
-    St::Distributions: app_state::IsSet,
     St::Name: app_state::IsSet,
+    St::Distributions: app_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> App<S> {
diff --git a/crates/jacquard-api/src/garden_lexicon/ngerakines/semeion/sign.rs b/crates/jacquard-api/src/garden_lexicon/ngerakines/semeion/sign.rs
index 9e58d65e..f801da46 100644
--- a/crates/jacquard-api/src/garden_lexicon/ngerakines/semeion/sign.rs
+++ b/crates/jacquard-api/src/garden_lexicon/ngerakines/semeion/sign.rs
@@ -66,7 +66,7 @@ impl jacquard_common::xrpc::XrpcRequest for Sign {
     type Response = SignResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/haus_opn/mic/artist.rs b/crates/jacquard-api/src/haus_opn/mic/artist.rs
index 6e856bc7..49dd2cb7 100644
--- a/crates/jacquard-api/src/haus_opn/mic/artist.rs
+++ b/crates/jacquard-api/src/haus_opn/mic/artist.rs
@@ -180,37 +180,37 @@ pub mod artist_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -339,8 +339,8 @@ where
 impl<S: BosStr, St> ArtistBuilder<S, St>
 where
     St: artist_state::State,
-    St::Name: artist_state::IsSet,
     St::CreatedAt: artist_state::IsSet,
+    St::Name: artist_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Artist<S> {
diff --git a/crates/jacquard-api/src/haus_opn/mic/show.rs b/crates/jacquard-api/src/haus_opn/mic/show.rs
index 21598191..3a5d55e5 100644
--- a/crates/jacquard-api/src/haus_opn/mic/show.rs
+++ b/crates/jacquard-api/src/haus_opn/mic/show.rs
@@ -273,67 +273,67 @@ pub mod show_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Title;
+        type Artist;
         type CreatedAt;
         type Schedule;
-        type Artist;
-        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Title = Unset;
+        type Artist = Unset;
         type CreatedAt = Unset;
         type Schedule = Unset;
-        type Artist = Unset;
-        type Title = Unset;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
+        type Artist = St::Artist;
+        type CreatedAt = St::CreatedAt;
+        type Schedule = St::Schedule;
+    }
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
+        type Title = St::Title;
+        type Artist = Set<members::artist>;
+        type CreatedAt = St::CreatedAt;
+        type Schedule = St::Schedule;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type Artist = St::Artist;
         type CreatedAt = Set<members::created_at>;
         type Schedule = St::Schedule;
-        type Artist = St::Artist;
-        type Title = St::Title;
     }
     ///State transition - sets the `schedule` field to Set
     pub struct SetSchedule<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSchedule<St> {}
     impl<St: State> State for SetSchedule<St> {
-        type CreatedAt = St::CreatedAt;
-        type Schedule = Set<members::schedule>;
-        type Artist = St::Artist;
-        type Title = St::Title;
-    }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
-        type CreatedAt = St::CreatedAt;
-        type Schedule = St::Schedule;
-        type Artist = Set<members::artist>;
         type Title = St::Title;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
-        type Schedule = St::Schedule;
         type Artist = St::Artist;
-        type Title = Set<members::title>;
+        type CreatedAt = St::CreatedAt;
+        type Schedule = Set<members::schedule>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `schedule` field
         pub struct schedule(());
-        ///Marker type for the `artist` field
-        pub struct artist(());
-        ///Marker type for the `title` field
-        pub struct title(());
     }
 }
 
@@ -474,10 +474,10 @@ where
 impl<S: BosStr, St> ShowBuilder<S, St>
 where
     St: show_state::State,
+    St::Title: show_state::IsSet,
+    St::Artist: show_state::IsSet,
     St::CreatedAt: show_state::IsSet,
     St::Schedule: show_state::IsSet,
-    St::Artist: show_state::IsSet,
-    St::Title: show_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Show<S> {
diff --git a/crates/jacquard-api/src/haus_opn/mic/show/episode.rs b/crates/jacquard-api/src/haus_opn/mic/show/episode.rs
index c0626f74..1ca55543 100644
--- a/crates/jacquard-api/src/haus_opn/mic/show/episode.rs
+++ b/crates/jacquard-api/src/haus_opn/mic/show/episode.rs
@@ -272,51 +272,51 @@ pub mod episode_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
-        type ShowUri;
         type CreatedAt;
+        type ShowUri;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
-        type ShowUri = Unset;
         type CreatedAt = Unset;
+        type ShowUri = Unset;
+        type Title = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type ShowUri = St::ShowUri;
-        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
     }
     ///State transition - sets the `show_uri` field to Set
     pub struct SetShowUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetShowUri<St> {}
     impl<St: State> State for SetShowUri<St> {
-        type Title = St::Title;
-        type ShowUri = Set<members::show_uri>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type ShowUri = Set<members::show_uri>;
         type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
         type ShowUri = St::ShowUri;
-        type CreatedAt = Set<members::created_at>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `show_uri` field
-        pub struct show_uri(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `show_uri` field
+        pub struct show_uri(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -479,9 +479,9 @@ impl<S: BosStr, St: episode_state::State> EpisodeBuilder<S, St> {
 impl<S: BosStr, St> EpisodeBuilder<S, St>
 where
     St: episode_state::State,
-    St::Title: episode_state::IsSet,
-    St::ShowUri: episode_state::IsSet,
     St::CreatedAt: episode_state::IsSet,
+    St::ShowUri: episode_state::IsSet,
+    St::Title: episode_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Episode<S> {
diff --git a/crates/jacquard-api/src/haus_opn/mic/show/episode/favorite.rs b/crates/jacquard-api/src/haus_opn/mic/show/episode/favorite.rs
index c46dbdd1..0eff9a8f 100644
--- a/crates/jacquard-api/src/haus_opn/mic/show/episode/favorite.rs
+++ b/crates/jacquard-api/src/haus_opn/mic/show/episode/favorite.rs
@@ -113,37 +113,37 @@ pub mod favorite_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> FavoriteBuilder<S, St>
 where
     St: favorite_state::State,
-    St::Subject: favorite_state::IsSet,
     St::CreatedAt: favorite_state::IsSet,
+    St::Subject: favorite_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Favorite<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/captain.rs b/crates/jacquard-api/src/io_atcr/hold/captain.rs
index dff3094e..7ed0e1a7 100644
--- a/crates/jacquard-api/src/io_atcr/hold/captain.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/captain.rs
@@ -136,85 +136,85 @@ pub mod captain_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AllowAllCrew;
+        type Owner;
         type EnableBlueskyPosts;
         type DeployedAt;
         type Public;
-        type Owner;
+        type AllowAllCrew;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AllowAllCrew = Unset;
+        type Owner = Unset;
         type EnableBlueskyPosts = Unset;
         type DeployedAt = Unset;
         type Public = Unset;
-        type Owner = Unset;
+        type AllowAllCrew = Unset;
     }
-    ///State transition - sets the `allow_all_crew` field to Set
-    pub struct SetAllowAllCrew<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAllowAllCrew<St> {}
-    impl<St: State> State for SetAllowAllCrew<St> {
-        type AllowAllCrew = Set<members::allow_all_crew>;
+    ///State transition - sets the `owner` field to Set
+    pub struct SetOwner<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOwner<St> {}
+    impl<St: State> State for SetOwner<St> {
+        type Owner = Set<members::owner>;
         type EnableBlueskyPosts = St::EnableBlueskyPosts;
         type DeployedAt = St::DeployedAt;
         type Public = St::Public;
-        type Owner = St::Owner;
+        type AllowAllCrew = St::AllowAllCrew;
     }
     ///State transition - sets the `enable_bluesky_posts` field to Set
     pub struct SetEnableBlueskyPosts<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEnableBlueskyPosts<St> {}
     impl<St: State> State for SetEnableBlueskyPosts<St> {
-        type AllowAllCrew = St::AllowAllCrew;
+        type Owner = St::Owner;
         type EnableBlueskyPosts = Set<members::enable_bluesky_posts>;
         type DeployedAt = St::DeployedAt;
         type Public = St::Public;
-        type Owner = St::Owner;
+        type AllowAllCrew = St::AllowAllCrew;
     }
     ///State transition - sets the `deployed_at` field to Set
     pub struct SetDeployedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDeployedAt<St> {}
     impl<St: State> State for SetDeployedAt<St> {
-        type AllowAllCrew = St::AllowAllCrew;
+        type Owner = St::Owner;
         type EnableBlueskyPosts = St::EnableBlueskyPosts;
         type DeployedAt = Set<members::deployed_at>;
         type Public = St::Public;
-        type Owner = St::Owner;
+        type AllowAllCrew = St::AllowAllCrew;
     }
     ///State transition - sets the `public` field to Set
     pub struct SetPublic<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublic<St> {}
     impl<St: State> State for SetPublic<St> {
-        type AllowAllCrew = St::AllowAllCrew;
+        type Owner = St::Owner;
         type EnableBlueskyPosts = St::EnableBlueskyPosts;
         type DeployedAt = St::DeployedAt;
         type Public = Set<members::public>;
-        type Owner = St::Owner;
-    }
-    ///State transition - sets the `owner` field to Set
-    pub struct SetOwner<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOwner<St> {}
-    impl<St: State> State for SetOwner<St> {
         type AllowAllCrew = St::AllowAllCrew;
+    }
+    ///State transition - sets the `allow_all_crew` field to Set
+    pub struct SetAllowAllCrew<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAllowAllCrew<St> {}
+    impl<St: State> State for SetAllowAllCrew<St> {
+        type Owner = St::Owner;
         type EnableBlueskyPosts = St::EnableBlueskyPosts;
         type DeployedAt = St::DeployedAt;
         type Public = St::Public;
-        type Owner = Set<members::owner>;
+        type AllowAllCrew = Set<members::allow_all_crew>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `allow_all_crew` field
-        pub struct allow_all_crew(());
+        ///Marker type for the `owner` field
+        pub struct owner(());
         ///Marker type for the `enable_bluesky_posts` field
         pub struct enable_bluesky_posts(());
         ///Marker type for the `deployed_at` field
         pub struct deployed_at(());
         ///Marker type for the `public` field
         pub struct public(());
-        ///Marker type for the `owner` field
-        pub struct owner(());
+        ///Marker type for the `allow_all_crew` field
+        pub struct allow_all_crew(());
     }
 }
 
@@ -375,11 +375,11 @@ impl<S: BosStr, St: captain_state::State> CaptainBuilder<S, St> {
 impl<S: BosStr, St> CaptainBuilder<S, St>
 where
     St: captain_state::State,
-    St::AllowAllCrew: captain_state::IsSet,
+    St::Owner: captain_state::IsSet,
     St::EnableBlueskyPosts: captain_state::IsSet,
     St::DeployedAt: captain_state::IsSet,
     St::Public: captain_state::IsSet,
-    St::Owner: captain_state::IsSet,
+    St::AllowAllCrew: captain_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Captain<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/complete_upload.rs b/crates/jacquard-api/src/io_atcr/hold/complete_upload.rs
index ed41b9da..32f047d8 100644
--- a/crates/jacquard-api/src/io_atcr/hold/complete_upload.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/complete_upload.rs
@@ -206,51 +206,51 @@ pub mod complete_upload_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Digest;
         type Parts;
         type UploadId;
-        type Digest;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Digest = Unset;
         type Parts = Unset;
         type UploadId = Unset;
-        type Digest = Unset;
+    }
+    ///State transition - sets the `digest` field to Set
+    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDigest<St> {}
+    impl<St: State> State for SetDigest<St> {
+        type Digest = Set<members::digest>;
+        type Parts = St::Parts;
+        type UploadId = St::UploadId;
     }
     ///State transition - sets the `parts` field to Set
     pub struct SetParts<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParts<St> {}
     impl<St: State> State for SetParts<St> {
+        type Digest = St::Digest;
         type Parts = Set<members::parts>;
         type UploadId = St::UploadId;
-        type Digest = St::Digest;
     }
     ///State transition - sets the `upload_id` field to Set
     pub struct SetUploadId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUploadId<St> {}
     impl<St: State> State for SetUploadId<St> {
-        type Parts = St::Parts;
-        type UploadId = Set<members::upload_id>;
         type Digest = St::Digest;
-    }
-    ///State transition - sets the `digest` field to Set
-    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDigest<St> {}
-    impl<St: State> State for SetDigest<St> {
         type Parts = St::Parts;
-        type UploadId = St::UploadId;
-        type Digest = Set<members::digest>;
+        type UploadId = Set<members::upload_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `digest` field
+        pub struct digest(());
         ///Marker type for the `parts` field
         pub struct parts(());
         ///Marker type for the `upload_id` field
         pub struct upload_id(());
-        ///Marker type for the `digest` field
-        pub struct digest(());
     }
 }
 
@@ -339,9 +339,9 @@ where
 impl<S: BosStr, St> CompleteUploadBuilder<S, St>
 where
     St: complete_upload_state::State,
+    St::Digest: complete_upload_state::IsSet,
     St::Parts: complete_upload_state::IsSet,
     St::UploadId: complete_upload_state::IsSet,
-    St::Digest: complete_upload_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CompleteUpload<S> {
@@ -376,37 +376,37 @@ pub mod part_info_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Etag;
         type PartNumber;
+        type Etag;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Etag = Unset;
         type PartNumber = Unset;
-    }
-    ///State transition - sets the `etag` field to Set
-    pub struct SetEtag<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEtag<St> {}
-    impl<St: State> State for SetEtag<St> {
-        type Etag = Set<members::etag>;
-        type PartNumber = St::PartNumber;
+        type Etag = Unset;
     }
     ///State transition - sets the `part_number` field to Set
     pub struct SetPartNumber<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPartNumber<St> {}
     impl<St: State> State for SetPartNumber<St> {
-        type Etag = St::Etag;
         type PartNumber = Set<members::part_number>;
+        type Etag = St::Etag;
+    }
+    ///State transition - sets the `etag` field to Set
+    pub struct SetEtag<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEtag<St> {}
+    impl<St: State> State for SetEtag<St> {
+        type PartNumber = St::PartNumber;
+        type Etag = Set<members::etag>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `etag` field
-        pub struct etag(());
         ///Marker type for the `part_number` field
         pub struct part_number(());
+        ///Marker type for the `etag` field
+        pub struct etag(());
     }
 }
 
@@ -476,8 +476,8 @@ where
 impl<S: BosStr, St> PartInfoBuilder<S, St>
 where
     St: part_info_state::State,
-    St::Etag: part_info_state::IsSet,
     St::PartNumber: part_info_state::IsSet,
+    St::Etag: part_info_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PartInfo<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/crew.rs b/crates/jacquard-api/src/io_atcr/hold/crew.rs
index 6ffaa0a2..ff80f874 100644
--- a/crates/jacquard-api/src/io_atcr/hold/crew.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/crew.rs
@@ -229,67 +229,67 @@ pub mod crew_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Member;
-        type Permissions;
         type Role;
         type AddedAt;
+        type Permissions;
+        type Member;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Member = Unset;
-        type Permissions = Unset;
         type Role = Unset;
         type AddedAt = Unset;
-    }
-    ///State transition - sets the `member` field to Set
-    pub struct SetMember<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMember<St> {}
-    impl<St: State> State for SetMember<St> {
-        type Member = Set<members::member>;
-        type Permissions = St::Permissions;
-        type Role = St::Role;
-        type AddedAt = St::AddedAt;
-    }
-    ///State transition - sets the `permissions` field to Set
-    pub struct SetPermissions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPermissions<St> {}
-    impl<St: State> State for SetPermissions<St> {
-        type Member = St::Member;
-        type Permissions = Set<members::permissions>;
-        type Role = St::Role;
-        type AddedAt = St::AddedAt;
+        type Permissions = Unset;
+        type Member = Unset;
     }
     ///State transition - sets the `role` field to Set
     pub struct SetRole<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRole<St> {}
     impl<St: State> State for SetRole<St> {
-        type Member = St::Member;
-        type Permissions = St::Permissions;
         type Role = Set<members::role>;
         type AddedAt = St::AddedAt;
+        type Permissions = St::Permissions;
+        type Member = St::Member;
     }
     ///State transition - sets the `added_at` field to Set
     pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAddedAt<St> {}
     impl<St: State> State for SetAddedAt<St> {
-        type Member = St::Member;
-        type Permissions = St::Permissions;
         type Role = St::Role;
         type AddedAt = Set<members::added_at>;
+        type Permissions = St::Permissions;
+        type Member = St::Member;
+    }
+    ///State transition - sets the `permissions` field to Set
+    pub struct SetPermissions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPermissions<St> {}
+    impl<St: State> State for SetPermissions<St> {
+        type Role = St::Role;
+        type AddedAt = St::AddedAt;
+        type Permissions = Set<members::permissions>;
+        type Member = St::Member;
+    }
+    ///State transition - sets the `member` field to Set
+    pub struct SetMember<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMember<St> {}
+    impl<St: State> State for SetMember<St> {
+        type Role = St::Role;
+        type AddedAt = St::AddedAt;
+        type Permissions = St::Permissions;
+        type Member = Set<members::member>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `member` field
-        pub struct member(());
-        ///Marker type for the `permissions` field
-        pub struct permissions(());
         ///Marker type for the `role` field
         pub struct role(());
         ///Marker type for the `added_at` field
         pub struct added_at(());
+        ///Marker type for the `permissions` field
+        pub struct permissions(());
+        ///Marker type for the `member` field
+        pub struct member(());
     }
 }
 
@@ -416,10 +416,10 @@ impl<S: BosStr, St: crew_state::State> CrewBuilder<S, St> {
 impl<S: BosStr, St> CrewBuilder<S, St>
 where
     St: crew_state::State,
-    St::Member: crew_state::IsSet,
-    St::Permissions: crew_state::IsSet,
     St::Role: crew_state::IsSet,
     St::AddedAt: crew_state::IsSet,
+    St::Permissions: crew_state::IsSet,
+    St::Member: crew_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Crew<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/layer.rs b/crates/jacquard-api/src/io_atcr/hold/layer.rs
index ee37b914..9ea9b338 100644
--- a/crates/jacquard-api/src/io_atcr/hold/layer.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/layer.rs
@@ -145,104 +145,104 @@ pub mod layer_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Size;
-        type CreatedAt;
-        type Digest;
         type MediaType;
         type Manifest;
         type UserDid;
+        type CreatedAt;
+        type Digest;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Size = Unset;
-        type CreatedAt = Unset;
-        type Digest = Unset;
         type MediaType = Unset;
         type Manifest = Unset;
         type UserDid = Unset;
+        type CreatedAt = Unset;
+        type Digest = Unset;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
         type Size = Set<members::size>;
-        type CreatedAt = St::CreatedAt;
-        type Digest = St::Digest;
-        type MediaType = St::MediaType;
-        type Manifest = St::Manifest;
-        type UserDid = St::UserDid;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Size = St::Size;
-        type CreatedAt = Set<members::created_at>;
-        type Digest = St::Digest;
         type MediaType = St::MediaType;
         type Manifest = St::Manifest;
         type UserDid = St::UserDid;
-    }
-    ///State transition - sets the `digest` field to Set
-    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDigest<St> {}
-    impl<St: State> State for SetDigest<St> {
-        type Size = St::Size;
         type CreatedAt = St::CreatedAt;
-        type Digest = Set<members::digest>;
-        type MediaType = St::MediaType;
-        type Manifest = St::Manifest;
-        type UserDid = St::UserDid;
+        type Digest = St::Digest;
     }
     ///State transition - sets the `media_type` field to Set
     pub struct SetMediaType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMediaType<St> {}
     impl<St: State> State for SetMediaType<St> {
         type Size = St::Size;
-        type CreatedAt = St::CreatedAt;
-        type Digest = St::Digest;
         type MediaType = Set<members::media_type>;
         type Manifest = St::Manifest;
         type UserDid = St::UserDid;
+        type CreatedAt = St::CreatedAt;
+        type Digest = St::Digest;
     }
     ///State transition - sets the `manifest` field to Set
     pub struct SetManifest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetManifest<St> {}
     impl<St: State> State for SetManifest<St> {
         type Size = St::Size;
-        type CreatedAt = St::CreatedAt;
-        type Digest = St::Digest;
         type MediaType = St::MediaType;
         type Manifest = Set<members::manifest>;
         type UserDid = St::UserDid;
+        type CreatedAt = St::CreatedAt;
+        type Digest = St::Digest;
     }
     ///State transition - sets the `user_did` field to Set
     pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUserDid<St> {}
     impl<St: State> State for SetUserDid<St> {
         type Size = St::Size;
+        type MediaType = St::MediaType;
+        type Manifest = St::Manifest;
+        type UserDid = Set<members::user_did>;
         type CreatedAt = St::CreatedAt;
         type Digest = St::Digest;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Size = St::Size;
         type MediaType = St::MediaType;
         type Manifest = St::Manifest;
-        type UserDid = Set<members::user_did>;
+        type UserDid = St::UserDid;
+        type CreatedAt = Set<members::created_at>;
+        type Digest = St::Digest;
+    }
+    ///State transition - sets the `digest` field to Set
+    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDigest<St> {}
+    impl<St: State> State for SetDigest<St> {
+        type Size = St::Size;
+        type MediaType = St::MediaType;
+        type Manifest = St::Manifest;
+        type UserDid = St::UserDid;
+        type CreatedAt = St::CreatedAt;
+        type Digest = Set<members::digest>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `size` field
         pub struct size(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `digest` field
-        pub struct digest(());
         ///Marker type for the `media_type` field
         pub struct media_type(());
         ///Marker type for the `manifest` field
         pub struct manifest(());
         ///Marker type for the `user_did` field
         pub struct user_did(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `digest` field
+        pub struct digest(());
     }
 }
 
@@ -396,11 +396,11 @@ impl<S: BosStr, St> LayerBuilder<S, St>
 where
     St: layer_state::State,
     St::Size: layer_state::IsSet,
-    St::CreatedAt: layer_state::IsSet,
-    St::Digest: layer_state::IsSet,
     St::MediaType: layer_state::IsSet,
     St::Manifest: layer_state::IsSet,
     St::UserDid: layer_state::IsSet,
+    St::CreatedAt: layer_state::IsSet,
+    St::Digest: layer_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Layer<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/notify_manifest.rs b/crates/jacquard-api/src/io_atcr/hold/notify_manifest.rs
index f1321b2d..a67598d5 100644
--- a/crates/jacquard-api/src/io_atcr/hold/notify_manifest.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/notify_manifest.rs
@@ -751,67 +751,67 @@ pub mod notify_manifest_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repository;
-        type UserDid;
         type ManifestDigest;
         type Manifest;
+        type UserDid;
+        type Repository;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repository = Unset;
-        type UserDid = Unset;
         type ManifestDigest = Unset;
         type Manifest = Unset;
-    }
-    ///State transition - sets the `repository` field to Set
-    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepository<St> {}
-    impl<St: State> State for SetRepository<St> {
-        type Repository = Set<members::repository>;
-        type UserDid = St::UserDid;
-        type ManifestDigest = St::ManifestDigest;
-        type Manifest = St::Manifest;
-    }
-    ///State transition - sets the `user_did` field to Set
-    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserDid<St> {}
-    impl<St: State> State for SetUserDid<St> {
-        type Repository = St::Repository;
-        type UserDid = Set<members::user_did>;
-        type ManifestDigest = St::ManifestDigest;
-        type Manifest = St::Manifest;
+        type UserDid = Unset;
+        type Repository = Unset;
     }
     ///State transition - sets the `manifest_digest` field to Set
     pub struct SetManifestDigest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetManifestDigest<St> {}
     impl<St: State> State for SetManifestDigest<St> {
-        type Repository = St::Repository;
-        type UserDid = St::UserDid;
         type ManifestDigest = Set<members::manifest_digest>;
         type Manifest = St::Manifest;
+        type UserDid = St::UserDid;
+        type Repository = St::Repository;
     }
     ///State transition - sets the `manifest` field to Set
     pub struct SetManifest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetManifest<St> {}
     impl<St: State> State for SetManifest<St> {
-        type Repository = St::Repository;
-        type UserDid = St::UserDid;
         type ManifestDigest = St::ManifestDigest;
         type Manifest = Set<members::manifest>;
+        type UserDid = St::UserDid;
+        type Repository = St::Repository;
+    }
+    ///State transition - sets the `user_did` field to Set
+    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserDid<St> {}
+    impl<St: State> State for SetUserDid<St> {
+        type ManifestDigest = St::ManifestDigest;
+        type Manifest = St::Manifest;
+        type UserDid = Set<members::user_did>;
+        type Repository = St::Repository;
+    }
+    ///State transition - sets the `repository` field to Set
+    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepository<St> {}
+    impl<St: State> State for SetRepository<St> {
+        type ManifestDigest = St::ManifestDigest;
+        type Manifest = St::Manifest;
+        type UserDid = St::UserDid;
+        type Repository = Set<members::repository>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repository` field
-        pub struct repository(());
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
         ///Marker type for the `manifest_digest` field
         pub struct manifest_digest(());
         ///Marker type for the `manifest` field
         pub struct manifest(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
     }
 }
 
@@ -955,10 +955,10 @@ where
 impl<S: BosStr, St> NotifyManifestBuilder<S, St>
 where
     St: notify_manifest_state::State,
-    St::Repository: notify_manifest_state::IsSet,
-    St::UserDid: notify_manifest_state::IsSet,
     St::ManifestDigest: notify_manifest_state::IsSet,
     St::Manifest: notify_manifest_state::IsSet,
+    St::UserDid: notify_manifest_state::IsSet,
+    St::Repository: notify_manifest_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotifyManifest<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/scan.rs b/crates/jacquard-api/src/io_atcr/hold/scan.rs
index febb0d1f..590b9f7e 100644
--- a/crates/jacquard-api/src/io_atcr/hold/scan.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/scan.rs
@@ -263,203 +263,203 @@ pub mod scan_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Medium;
+        type Repository;
+        type Critical;
         type Total;
-        type UserDid;
+        type ScannedAt;
         type Manifest;
-        type Low;
+        type Medium;
+        type UserDid;
         type ScannerVersion;
-        type Critical;
-        type ScannedAt;
-        type Repository;
+        type Low;
         type High;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Medium = Unset;
+        type Repository = Unset;
+        type Critical = Unset;
         type Total = Unset;
-        type UserDid = Unset;
+        type ScannedAt = Unset;
         type Manifest = Unset;
-        type Low = Unset;
+        type Medium = Unset;
+        type UserDid = Unset;
         type ScannerVersion = Unset;
-        type Critical = Unset;
-        type ScannedAt = Unset;
-        type Repository = Unset;
+        type Low = Unset;
         type High = Unset;
     }
-    ///State transition - sets the `medium` field to Set
-    pub struct SetMedium<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMedium<St> {}
-    impl<St: State> State for SetMedium<St> {
-        type Medium = Set<members::medium>;
+    ///State transition - sets the `repository` field to Set
+    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepository<St> {}
+    impl<St: State> State for SetRepository<St> {
+        type Repository = Set<members::repository>;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = St::Manifest;
-        type Low = St::Low;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
+        type Low = St::Low;
+        type High = St::High;
+    }
+    ///State transition - sets the `critical` field to Set
+    pub struct SetCritical<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCritical<St> {}
+    impl<St: State> State for SetCritical<St> {
         type Repository = St::Repository;
+        type Critical = Set<members::critical>;
+        type Total = St::Total;
+        type ScannedAt = St::ScannedAt;
+        type Manifest = St::Manifest;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
+        type ScannerVersion = St::ScannerVersion;
+        type Low = St::Low;
         type High = St::High;
     }
     ///State transition - sets the `total` field to Set
     pub struct SetTotal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotal<St> {}
     impl<St: State> State for SetTotal<St> {
-        type Medium = St::Medium;
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = Set<members::total>;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = St::Manifest;
-        type Low = St::Low;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
+        type Low = St::Low;
         type High = St::High;
     }
-    ///State transition - sets the `user_did` field to Set
-    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserDid<St> {}
-    impl<St: State> State for SetUserDid<St> {
-        type Medium = St::Medium;
+    ///State transition - sets the `scanned_at` field to Set
+    pub struct SetScannedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScannedAt<St> {}
+    impl<St: State> State for SetScannedAt<St> {
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = Set<members::user_did>;
+        type ScannedAt = Set<members::scanned_at>;
         type Manifest = St::Manifest;
-        type Low = St::Low;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
+        type Low = St::Low;
         type High = St::High;
     }
     ///State transition - sets the `manifest` field to Set
     pub struct SetManifest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetManifest<St> {}
     impl<St: State> State for SetManifest<St> {
-        type Medium = St::Medium;
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = Set<members::manifest>;
-        type Low = St::Low;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
+        type Low = St::Low;
         type High = St::High;
     }
-    ///State transition - sets the `low` field to Set
-    pub struct SetLow<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLow<St> {}
-    impl<St: State> State for SetLow<St> {
-        type Medium = St::Medium;
+    ///State transition - sets the `medium` field to Set
+    pub struct SetMedium<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMedium<St> {}
+    impl<St: State> State for SetMedium<St> {
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = St::Manifest;
-        type Low = Set<members::low>;
+        type Medium = Set<members::medium>;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
+        type Low = St::Low;
+        type High = St::High;
+    }
+    ///State transition - sets the `user_did` field to Set
+    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserDid<St> {}
+    impl<St: State> State for SetUserDid<St> {
+        type Repository = St::Repository;
         type Critical = St::Critical;
+        type Total = St::Total;
         type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
+        type Manifest = St::Manifest;
+        type Medium = St::Medium;
+        type UserDid = Set<members::user_did>;
+        type ScannerVersion = St::ScannerVersion;
+        type Low = St::Low;
         type High = St::High;
     }
     ///State transition - sets the `scanner_version` field to Set
     pub struct SetScannerVersion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScannerVersion<St> {}
     impl<St: State> State for SetScannerVersion<St> {
-        type Medium = St::Medium;
-        type Total = St::Total;
-        type UserDid = St::UserDid;
-        type Manifest = St::Manifest;
-        type Low = St::Low;
-        type ScannerVersion = Set<members::scanner_version>;
+        type Repository = St::Repository;
         type Critical = St::Critical;
+        type Total = St::Total;
         type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
-        type High = St::High;
-    }
-    ///State transition - sets the `critical` field to Set
-    pub struct SetCritical<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCritical<St> {}
-    impl<St: State> State for SetCritical<St> {
+        type Manifest = St::Manifest;
         type Medium = St::Medium;
-        type Total = St::Total;
         type UserDid = St::UserDid;
-        type Manifest = St::Manifest;
+        type ScannerVersion = Set<members::scanner_version>;
         type Low = St::Low;
-        type ScannerVersion = St::ScannerVersion;
-        type Critical = Set<members::critical>;
-        type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
         type High = St::High;
     }
-    ///State transition - sets the `scanned_at` field to Set
-    pub struct SetScannedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScannedAt<St> {}
-    impl<St: State> State for SetScannedAt<St> {
-        type Medium = St::Medium;
+    ///State transition - sets the `low` field to Set
+    pub struct SetLow<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLow<St> {}
+    impl<St: State> State for SetLow<St> {
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = St::Manifest;
-        type Low = St::Low;
-        type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = Set<members::scanned_at>;
-        type Repository = St::Repository;
-        type High = St::High;
-    }
-    ///State transition - sets the `repository` field to Set
-    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepository<St> {}
-    impl<St: State> State for SetRepository<St> {
         type Medium = St::Medium;
-        type Total = St::Total;
         type UserDid = St::UserDid;
-        type Manifest = St::Manifest;
-        type Low = St::Low;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
-        type Repository = Set<members::repository>;
+        type Low = Set<members::low>;
         type High = St::High;
     }
     ///State transition - sets the `high` field to Set
     pub struct SetHigh<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHigh<St> {}
     impl<St: State> State for SetHigh<St> {
-        type Medium = St::Medium;
+        type Repository = St::Repository;
+        type Critical = St::Critical;
         type Total = St::Total;
-        type UserDid = St::UserDid;
+        type ScannedAt = St::ScannedAt;
         type Manifest = St::Manifest;
-        type Low = St::Low;
+        type Medium = St::Medium;
+        type UserDid = St::UserDid;
         type ScannerVersion = St::ScannerVersion;
-        type Critical = St::Critical;
-        type ScannedAt = St::ScannedAt;
-        type Repository = St::Repository;
+        type Low = St::Low;
         type High = Set<members::high>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `medium` field
-        pub struct medium(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
+        ///Marker type for the `critical` field
+        pub struct critical(());
         ///Marker type for the `total` field
         pub struct total(());
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
+        ///Marker type for the `scanned_at` field
+        pub struct scanned_at(());
         ///Marker type for the `manifest` field
         pub struct manifest(());
-        ///Marker type for the `low` field
-        pub struct low(());
+        ///Marker type for the `medium` field
+        pub struct medium(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
         ///Marker type for the `scanner_version` field
         pub struct scanner_version(());
-        ///Marker type for the `critical` field
-        pub struct critical(());
-        ///Marker type for the `scanned_at` field
-        pub struct scanned_at(());
-        ///Marker type for the `repository` field
-        pub struct repository(());
+        ///Marker type for the `low` field
+        pub struct low(());
         ///Marker type for the `high` field
         pub struct high(());
     }
@@ -735,15 +735,15 @@ impl<S: BosStr, St: scan_state::State> ScanBuilder<S, St> {
 impl<S: BosStr, St> ScanBuilder<S, St>
 where
     St: scan_state::State,
-    St::Medium: scan_state::IsSet,
+    St::Repository: scan_state::IsSet,
+    St::Critical: scan_state::IsSet,
     St::Total: scan_state::IsSet,
-    St::UserDid: scan_state::IsSet,
+    St::ScannedAt: scan_state::IsSet,
     St::Manifest: scan_state::IsSet,
-    St::Low: scan_state::IsSet,
+    St::Medium: scan_state::IsSet,
+    St::UserDid: scan_state::IsSet,
     St::ScannerVersion: scan_state::IsSet,
-    St::Critical: scan_state::IsSet,
-    St::ScannedAt: scan_state::IsSet,
-    St::Repository: scan_state::IsSet,
+    St::Low: scan_state::IsSet,
     St::High: scan_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/io_atcr/hold/set_stats.rs b/crates/jacquard-api/src/io_atcr/hold/set_stats.rs
index 5c9a531b..000c5f17 100644
--- a/crates/jacquard-api/src/io_atcr/hold/set_stats.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/set_stats.rs
@@ -139,37 +139,37 @@ pub mod set_stats_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type OwnerDid;
         type Repository;
+        type OwnerDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type OwnerDid = Unset;
         type Repository = Unset;
-    }
-    ///State transition - sets the `owner_did` field to Set
-    pub struct SetOwnerDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOwnerDid<St> {}
-    impl<St: State> State for SetOwnerDid<St> {
-        type OwnerDid = Set<members::owner_did>;
-        type Repository = St::Repository;
+        type OwnerDid = Unset;
     }
     ///State transition - sets the `repository` field to Set
     pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepository<St> {}
     impl<St: State> State for SetRepository<St> {
-        type OwnerDid = St::OwnerDid;
         type Repository = Set<members::repository>;
+        type OwnerDid = St::OwnerDid;
+    }
+    ///State transition - sets the `owner_did` field to Set
+    pub struct SetOwnerDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOwnerDid<St> {}
+    impl<St: State> State for SetOwnerDid<St> {
+        type Repository = St::Repository;
+        type OwnerDid = Set<members::owner_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `owner_did` field
-        pub struct owner_did(());
         ///Marker type for the `repository` field
         pub struct repository(());
+        ///Marker type for the `owner_did` field
+        pub struct owner_did(());
     }
 }
 
@@ -298,8 +298,8 @@ where
 impl<S: BosStr, St> SetStatsBuilder<S, St>
 where
     St: set_stats_state::State,
-    St::OwnerDid: set_stats_state::IsSet,
     St::Repository: set_stats_state::IsSet,
+    St::OwnerDid: set_stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SetStats<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/stats.rs b/crates/jacquard-api/src/io_atcr/hold/stats.rs
index f913fbca..78c81cb6 100644
--- a/crates/jacquard-api/src/io_atcr/hold/stats.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/stats.rs
@@ -157,85 +157,85 @@ pub mod stats_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repository;
-        type OwnerDid;
         type UpdatedAt;
-        type PushCount;
+        type OwnerDid;
         type PullCount;
+        type Repository;
+        type PushCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repository = Unset;
-        type OwnerDid = Unset;
         type UpdatedAt = Unset;
-        type PushCount = Unset;
+        type OwnerDid = Unset;
         type PullCount = Unset;
+        type Repository = Unset;
+        type PushCount = Unset;
     }
-    ///State transition - sets the `repository` field to Set
-    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepository<St> {}
-    impl<St: State> State for SetRepository<St> {
-        type Repository = Set<members::repository>;
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type UpdatedAt = Set<members::updated_at>;
         type OwnerDid = St::OwnerDid;
-        type UpdatedAt = St::UpdatedAt;
-        type PushCount = St::PushCount;
         type PullCount = St::PullCount;
+        type Repository = St::Repository;
+        type PushCount = St::PushCount;
     }
     ///State transition - sets the `owner_did` field to Set
     pub struct SetOwnerDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOwnerDid<St> {}
     impl<St: State> State for SetOwnerDid<St> {
-        type Repository = St::Repository;
-        type OwnerDid = Set<members::owner_did>;
         type UpdatedAt = St::UpdatedAt;
-        type PushCount = St::PushCount;
+        type OwnerDid = Set<members::owner_did>;
         type PullCount = St::PullCount;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
         type Repository = St::Repository;
+        type PushCount = St::PushCount;
+    }
+    ///State transition - sets the `pull_count` field to Set
+    pub struct SetPullCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPullCount<St> {}
+    impl<St: State> State for SetPullCount<St> {
+        type UpdatedAt = St::UpdatedAt;
         type OwnerDid = St::OwnerDid;
-        type UpdatedAt = Set<members::updated_at>;
+        type PullCount = Set<members::pull_count>;
+        type Repository = St::Repository;
         type PushCount = St::PushCount;
+    }
+    ///State transition - sets the `repository` field to Set
+    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepository<St> {}
+    impl<St: State> State for SetRepository<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type OwnerDid = St::OwnerDid;
         type PullCount = St::PullCount;
+        type Repository = Set<members::repository>;
+        type PushCount = St::PushCount;
     }
     ///State transition - sets the `push_count` field to Set
     pub struct SetPushCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPushCount<St> {}
     impl<St: State> State for SetPushCount<St> {
-        type Repository = St::Repository;
-        type OwnerDid = St::OwnerDid;
         type UpdatedAt = St::UpdatedAt;
-        type PushCount = Set<members::push_count>;
+        type OwnerDid = St::OwnerDid;
         type PullCount = St::PullCount;
-    }
-    ///State transition - sets the `pull_count` field to Set
-    pub struct SetPullCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPullCount<St> {}
-    impl<St: State> State for SetPullCount<St> {
         type Repository = St::Repository;
-        type OwnerDid = St::OwnerDid;
-        type UpdatedAt = St::UpdatedAt;
-        type PushCount = St::PushCount;
-        type PullCount = Set<members::pull_count>;
+        type PushCount = Set<members::push_count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repository` field
-        pub struct repository(());
-        ///Marker type for the `owner_did` field
-        pub struct owner_did(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
-        ///Marker type for the `push_count` field
-        pub struct push_count(());
+        ///Marker type for the `owner_did` field
+        pub struct owner_did(());
         ///Marker type for the `pull_count` field
         pub struct pull_count(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
+        ///Marker type for the `push_count` field
+        pub struct push_count(());
     }
 }
 
@@ -396,11 +396,11 @@ where
 impl<S: BosStr, St> StatsBuilder<S, St>
 where
     St: stats_state::State,
-    St::Repository: stats_state::IsSet,
-    St::OwnerDid: stats_state::IsSet,
     St::UpdatedAt: stats_state::IsSet,
-    St::PushCount: stats_state::IsSet,
+    St::OwnerDid: stats_state::IsSet,
     St::PullCount: stats_state::IsSet,
+    St::Repository: stats_state::IsSet,
+    St::PushCount: stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Stats<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/subscribe_scan_jobs.rs b/crates/jacquard-api/src/io_atcr/hold/subscribe_scan_jobs.rs
index d8eba78d..093a4a1e 100644
--- a/crates/jacquard-api/src/io_atcr/hold/subscribe_scan_jobs.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/subscribe_scan_jobs.rs
@@ -478,127 +478,127 @@ pub mod scan_job_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type UserDid;
-        type Type;
-        type Repository;
-        type Digest;
         type Seq;
         type HoldDid;
         type HoldEndpoint;
+        type Digest;
+        type Type;
+        type Repository;
+        type UserDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type UserDid = Unset;
-        type Type = Unset;
-        type Repository = Unset;
-        type Digest = Unset;
         type Seq = Unset;
         type HoldDid = Unset;
         type HoldEndpoint = Unset;
+        type Digest = Unset;
+        type Type = Unset;
+        type Repository = Unset;
+        type UserDid = Unset;
     }
-    ///State transition - sets the `user_did` field to Set
-    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserDid<St> {}
-    impl<St: State> State for SetUserDid<St> {
-        type UserDid = Set<members::user_did>;
+    ///State transition - sets the `seq` field to Set
+    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSeq<St> {}
+    impl<St: State> State for SetSeq<St> {
+        type Seq = Set<members::seq>;
+        type HoldDid = St::HoldDid;
+        type HoldEndpoint = St::HoldEndpoint;
+        type Digest = St::Digest;
         type Type = St::Type;
         type Repository = St::Repository;
+        type UserDid = St::UserDid;
+    }
+    ///State transition - sets the `hold_did` field to Set
+    pub struct SetHoldDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHoldDid<St> {}
+    impl<St: State> State for SetHoldDid<St> {
+        type Seq = St::Seq;
+        type HoldDid = Set<members::hold_did>;
+        type HoldEndpoint = St::HoldEndpoint;
         type Digest = St::Digest;
+        type Type = St::Type;
+        type Repository = St::Repository;
+        type UserDid = St::UserDid;
+    }
+    ///State transition - sets the `hold_endpoint` field to Set
+    pub struct SetHoldEndpoint<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHoldEndpoint<St> {}
+    impl<St: State> State for SetHoldEndpoint<St> {
+        type Seq = St::Seq;
+        type HoldDid = St::HoldDid;
+        type HoldEndpoint = Set<members::hold_endpoint>;
+        type Digest = St::Digest;
+        type Type = St::Type;
+        type Repository = St::Repository;
+        type UserDid = St::UserDid;
+    }
+    ///State transition - sets the `digest` field to Set
+    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDigest<St> {}
+    impl<St: State> State for SetDigest<St> {
         type Seq = St::Seq;
         type HoldDid = St::HoldDid;
         type HoldEndpoint = St::HoldEndpoint;
+        type Digest = Set<members::digest>;
+        type Type = St::Type;
+        type Repository = St::Repository;
+        type UserDid = St::UserDid;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type UserDid = St::UserDid;
-        type Type = Set<members::r#type>;
-        type Repository = St::Repository;
-        type Digest = St::Digest;
         type Seq = St::Seq;
         type HoldDid = St::HoldDid;
         type HoldEndpoint = St::HoldEndpoint;
+        type Digest = St::Digest;
+        type Type = Set<members::r#type>;
+        type Repository = St::Repository;
+        type UserDid = St::UserDid;
     }
     ///State transition - sets the `repository` field to Set
     pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepository<St> {}
     impl<St: State> State for SetRepository<St> {
-        type UserDid = St::UserDid;
-        type Type = St::Type;
-        type Repository = Set<members::repository>;
-        type Digest = St::Digest;
         type Seq = St::Seq;
         type HoldDid = St::HoldDid;
         type HoldEndpoint = St::HoldEndpoint;
-    }
-    ///State transition - sets the `digest` field to Set
-    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDigest<St> {}
-    impl<St: State> State for SetDigest<St> {
-        type UserDid = St::UserDid;
+        type Digest = St::Digest;
         type Type = St::Type;
-        type Repository = St::Repository;
-        type Digest = Set<members::digest>;
-        type Seq = St::Seq;
-        type HoldDid = St::HoldDid;
-        type HoldEndpoint = St::HoldEndpoint;
-    }
-    ///State transition - sets the `seq` field to Set
-    pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSeq<St> {}
-    impl<St: State> State for SetSeq<St> {
+        type Repository = Set<members::repository>;
         type UserDid = St::UserDid;
-        type Type = St::Type;
-        type Repository = St::Repository;
-        type Digest = St::Digest;
-        type Seq = Set<members::seq>;
-        type HoldDid = St::HoldDid;
-        type HoldEndpoint = St::HoldEndpoint;
     }
-    ///State transition - sets the `hold_did` field to Set
-    pub struct SetHoldDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHoldDid<St> {}
-    impl<St: State> State for SetHoldDid<St> {
-        type UserDid = St::UserDid;
-        type Type = St::Type;
-        type Repository = St::Repository;
-        type Digest = St::Digest;
+    ///State transition - sets the `user_did` field to Set
+    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserDid<St> {}
+    impl<St: State> State for SetUserDid<St> {
         type Seq = St::Seq;
-        type HoldDid = Set<members::hold_did>;
+        type HoldDid = St::HoldDid;
         type HoldEndpoint = St::HoldEndpoint;
-    }
-    ///State transition - sets the `hold_endpoint` field to Set
-    pub struct SetHoldEndpoint<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHoldEndpoint<St> {}
-    impl<St: State> State for SetHoldEndpoint<St> {
-        type UserDid = St::UserDid;
+        type Digest = St::Digest;
         type Type = St::Type;
         type Repository = St::Repository;
-        type Digest = St::Digest;
-        type Seq = St::Seq;
-        type HoldDid = St::HoldDid;
-        type HoldEndpoint = Set<members::hold_endpoint>;
+        type UserDid = Set<members::user_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
-        ///Marker type for the `repository` field
-        pub struct repository(());
-        ///Marker type for the `digest` field
-        pub struct digest(());
         ///Marker type for the `seq` field
         pub struct seq(());
         ///Marker type for the `hold_did` field
         pub struct hold_did(());
         ///Marker type for the `hold_endpoint` field
         pub struct hold_endpoint(());
+        ///Marker type for the `digest` field
+        pub struct digest(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
     }
 }
 
@@ -799,13 +799,13 @@ where
 impl<S: BosStr, St> ScanJobBuilder<S, St>
 where
     St: scan_job_state::State,
-    St::UserDid: scan_job_state::IsSet,
-    St::Type: scan_job_state::IsSet,
-    St::Repository: scan_job_state::IsSet,
-    St::Digest: scan_job_state::IsSet,
     St::Seq: scan_job_state::IsSet,
     St::HoldDid: scan_job_state::IsSet,
     St::HoldEndpoint: scan_job_state::IsSet,
+    St::Digest: scan_job_state::IsSet,
+    St::Type: scan_job_state::IsSet,
+    St::Repository: scan_job_state::IsSet,
+    St::UserDid: scan_job_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ScanJob<S> {
@@ -1375,83 +1375,83 @@ pub mod vuln_summary_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Critical;
         type Medium;
-        type High;
         type Total;
+        type Critical;
+        type High;
         type Low;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Critical = Unset;
         type Medium = Unset;
-        type High = Unset;
         type Total = Unset;
+        type Critical = Unset;
+        type High = Unset;
         type Low = Unset;
     }
-    ///State transition - sets the `critical` field to Set
-    pub struct SetCritical<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCritical<St> {}
-    impl<St: State> State for SetCritical<St> {
-        type Critical = Set<members::critical>;
-        type Medium = St::Medium;
-        type High = St::High;
-        type Total = St::Total;
-        type Low = St::Low;
-    }
     ///State transition - sets the `medium` field to Set
     pub struct SetMedium<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMedium<St> {}
     impl<St: State> State for SetMedium<St> {
-        type Critical = St::Critical;
         type Medium = Set<members::medium>;
-        type High = St::High;
         type Total = St::Total;
-        type Low = St::Low;
-    }
-    ///State transition - sets the `high` field to Set
-    pub struct SetHigh<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHigh<St> {}
-    impl<St: State> State for SetHigh<St> {
         type Critical = St::Critical;
-        type Medium = St::Medium;
-        type High = Set<members::high>;
-        type Total = St::Total;
+        type High = St::High;
         type Low = St::Low;
     }
     ///State transition - sets the `total` field to Set
     pub struct SetTotal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotal<St> {}
     impl<St: State> State for SetTotal<St> {
+        type Medium = St::Medium;
+        type Total = Set<members::total>;
         type Critical = St::Critical;
+        type High = St::High;
+        type Low = St::Low;
+    }
+    ///State transition - sets the `critical` field to Set
+    pub struct SetCritical<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCritical<St> {}
+    impl<St: State> State for SetCritical<St> {
         type Medium = St::Medium;
+        type Total = St::Total;
+        type Critical = Set<members::critical>;
         type High = St::High;
-        type Total = Set<members::total>;
+        type Low = St::Low;
+    }
+    ///State transition - sets the `high` field to Set
+    pub struct SetHigh<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHigh<St> {}
+    impl<St: State> State for SetHigh<St> {
+        type Medium = St::Medium;
+        type Total = St::Total;
+        type Critical = St::Critical;
+        type High = Set<members::high>;
         type Low = St::Low;
     }
     ///State transition - sets the `low` field to Set
     pub struct SetLow<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLow<St> {}
     impl<St: State> State for SetLow<St> {
-        type Critical = St::Critical;
         type Medium = St::Medium;
-        type High = St::High;
         type Total = St::Total;
+        type Critical = St::Critical;
+        type High = St::High;
         type Low = Set<members::low>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `critical` field
-        pub struct critical(());
         ///Marker type for the `medium` field
         pub struct medium(());
-        ///Marker type for the `high` field
-        pub struct high(());
         ///Marker type for the `total` field
         pub struct total(());
+        ///Marker type for the `critical` field
+        pub struct critical(());
+        ///Marker type for the `high` field
+        pub struct high(());
         ///Marker type for the `low` field
         pub struct low(());
     }
@@ -1580,10 +1580,10 @@ where
 impl<S: BosStr, St> VulnSummaryBuilder<S, St>
 where
     St: vuln_summary_state::State,
-    St::Critical: vuln_summary_state::IsSet,
     St::Medium: vuln_summary_state::IsSet,
-    St::High: vuln_summary_state::IsSet,
     St::Total: vuln_summary_state::IsSet,
+    St::Critical: vuln_summary_state::IsSet,
+    St::High: vuln_summary_state::IsSet,
     St::Low: vuln_summary_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/io_atcr/hold/update_crew_tier.rs b/crates/jacquard-api/src/io_atcr/hold/update_crew_tier.rs
index b4a79295..b859c16e 100644
--- a/crates/jacquard-api/src/io_atcr/hold/update_crew_tier.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/update_crew_tier.rs
@@ -129,37 +129,37 @@ pub mod update_crew_tier_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TierRank;
         type UserDid;
+        type TierRank;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TierRank = Unset;
         type UserDid = Unset;
-    }
-    ///State transition - sets the `tier_rank` field to Set
-    pub struct SetTierRank<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTierRank<St> {}
-    impl<St: State> State for SetTierRank<St> {
-        type TierRank = Set<members::tier_rank>;
-        type UserDid = St::UserDid;
+        type TierRank = Unset;
     }
     ///State transition - sets the `user_did` field to Set
     pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUserDid<St> {}
     impl<St: State> State for SetUserDid<St> {
-        type TierRank = St::TierRank;
         type UserDid = Set<members::user_did>;
+        type TierRank = St::TierRank;
+    }
+    ///State transition - sets the `tier_rank` field to Set
+    pub struct SetTierRank<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTierRank<St> {}
+    impl<St: State> State for SetTierRank<St> {
+        type UserDid = St::UserDid;
+        type TierRank = Set<members::tier_rank>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `tier_rank` field
-        pub struct tier_rank(());
         ///Marker type for the `user_did` field
         pub struct user_did(());
+        ///Marker type for the `tier_rank` field
+        pub struct tier_rank(());
     }
 }
 
@@ -229,8 +229,8 @@ where
 impl<S: BosStr, St> UpdateCrewTierBuilder<S, St>
 where
     St: update_crew_tier_state::State,
-    St::TierRank: update_crew_tier_state::IsSet,
     St::UserDid: update_crew_tier_state::IsSet,
+    St::TierRank: update_crew_tier_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateCrewTier<S> {
diff --git a/crates/jacquard-api/src/io_atcr/hold/upload_part.rs b/crates/jacquard-api/src/io_atcr/hold/upload_part.rs
index 5dba4ebc..c8af4bf3 100644
--- a/crates/jacquard-api/src/io_atcr/hold/upload_part.rs
+++ b/crates/jacquard-api/src/io_atcr/hold/upload_part.rs
@@ -111,7 +111,7 @@ impl jacquard_common::xrpc::XrpcRequest for UploadPart {
     type Response = UploadPartResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/io_atcr/manifest.rs b/crates/jacquard-api/src/io_atcr/manifest.rs
index b29ad641..0f24e46c 100644
--- a/crates/jacquard-api/src/io_atcr/manifest.rs
+++ b/crates/jacquard-api/src/io_atcr/manifest.rs
@@ -485,51 +485,51 @@ pub mod blob_reference_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Size;
         type Digest;
         type MediaType;
-        type Size;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Size = Unset;
         type Digest = Unset;
         type MediaType = Unset;
-        type Size = Unset;
+    }
+    ///State transition - sets the `size` field to Set
+    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSize<St> {}
+    impl<St: State> State for SetSize<St> {
+        type Size = Set<members::size>;
+        type Digest = St::Digest;
+        type MediaType = St::MediaType;
     }
     ///State transition - sets the `digest` field to Set
     pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDigest<St> {}
     impl<St: State> State for SetDigest<St> {
+        type Size = St::Size;
         type Digest = Set<members::digest>;
         type MediaType = St::MediaType;
-        type Size = St::Size;
     }
     ///State transition - sets the `media_type` field to Set
     pub struct SetMediaType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMediaType<St> {}
     impl<St: State> State for SetMediaType<St> {
-        type Digest = St::Digest;
-        type MediaType = Set<members::media_type>;
         type Size = St::Size;
-    }
-    ///State transition - sets the `size` field to Set
-    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSize<St> {}
-    impl<St: State> State for SetSize<St> {
         type Digest = St::Digest;
-        type MediaType = St::MediaType;
-        type Size = Set<members::size>;
+        type MediaType = Set<members::media_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `size` field
+        pub struct size(());
         ///Marker type for the `digest` field
         pub struct digest(());
         ///Marker type for the `media_type` field
         pub struct media_type(());
-        ///Marker type for the `size` field
-        pub struct size(());
     }
 }
 
@@ -650,9 +650,9 @@ impl<S: BosStr, St: blob_reference_state::State> BlobReferenceBuilder<S, St> {
 impl<S: BosStr, St> BlobReferenceBuilder<S, St>
 where
     St: blob_reference_state::State,
+    St::Size: blob_reference_state::IsSet,
     St::Digest: blob_reference_state::IsSet,
     St::MediaType: blob_reference_state::IsSet,
-    St::Size: blob_reference_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BlobReference<S> {
@@ -1073,85 +1073,85 @@ pub mod manifest_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MediaType;
-        type Repository;
-        type Digest;
         type CreatedAt;
+        type MediaType;
         type SchemaVersion;
+        type Digest;
+        type Repository;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MediaType = Unset;
-        type Repository = Unset;
-        type Digest = Unset;
         type CreatedAt = Unset;
+        type MediaType = Unset;
         type SchemaVersion = Unset;
+        type Digest = Unset;
+        type Repository = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type MediaType = St::MediaType;
+        type SchemaVersion = St::SchemaVersion;
+        type Digest = St::Digest;
+        type Repository = St::Repository;
     }
     ///State transition - sets the `media_type` field to Set
     pub struct SetMediaType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMediaType<St> {}
     impl<St: State> State for SetMediaType<St> {
-        type MediaType = Set<members::media_type>;
-        type Repository = St::Repository;
-        type Digest = St::Digest;
         type CreatedAt = St::CreatedAt;
+        type MediaType = Set<members::media_type>;
         type SchemaVersion = St::SchemaVersion;
+        type Digest = St::Digest;
+        type Repository = St::Repository;
     }
-    ///State transition - sets the `repository` field to Set
-    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepository<St> {}
-    impl<St: State> State for SetRepository<St> {
+    ///State transition - sets the `schema_version` field to Set
+    pub struct SetSchemaVersion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSchemaVersion<St> {}
+    impl<St: State> State for SetSchemaVersion<St> {
+        type CreatedAt = St::CreatedAt;
         type MediaType = St::MediaType;
-        type Repository = Set<members::repository>;
+        type SchemaVersion = Set<members::schema_version>;
         type Digest = St::Digest;
-        type CreatedAt = St::CreatedAt;
-        type SchemaVersion = St::SchemaVersion;
+        type Repository = St::Repository;
     }
     ///State transition - sets the `digest` field to Set
     pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDigest<St> {}
     impl<St: State> State for SetDigest<St> {
-        type MediaType = St::MediaType;
-        type Repository = St::Repository;
-        type Digest = Set<members::digest>;
         type CreatedAt = St::CreatedAt;
-        type SchemaVersion = St::SchemaVersion;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type MediaType = St::MediaType;
-        type Repository = St::Repository;
-        type Digest = St::Digest;
-        type CreatedAt = Set<members::created_at>;
         type SchemaVersion = St::SchemaVersion;
+        type Digest = Set<members::digest>;
+        type Repository = St::Repository;
     }
-    ///State transition - sets the `schema_version` field to Set
-    pub struct SetSchemaVersion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSchemaVersion<St> {}
-    impl<St: State> State for SetSchemaVersion<St> {
+    ///State transition - sets the `repository` field to Set
+    pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepository<St> {}
+    impl<St: State> State for SetRepository<St> {
+        type CreatedAt = St::CreatedAt;
         type MediaType = St::MediaType;
-        type Repository = St::Repository;
+        type SchemaVersion = St::SchemaVersion;
         type Digest = St::Digest;
-        type CreatedAt = St::CreatedAt;
-        type SchemaVersion = Set<members::schema_version>;
+        type Repository = Set<members::repository>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `media_type` field
-        pub struct media_type(());
-        ///Marker type for the `repository` field
-        pub struct repository(());
-        ///Marker type for the `digest` field
-        pub struct digest(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `media_type` field
+        pub struct media_type(());
         ///Marker type for the `schema_version` field
         pub struct schema_version(());
+        ///Marker type for the `digest` field
+        pub struct digest(());
+        ///Marker type for the `repository` field
+        pub struct repository(());
     }
 }
 
@@ -1428,11 +1428,11 @@ impl<S: BosStr, St: manifest_state::State> ManifestBuilder<S, St> {
 impl<S: BosStr, St> ManifestBuilder<S, St>
 where
     St: manifest_state::State,
-    St::MediaType: manifest_state::IsSet,
-    St::Repository: manifest_state::IsSet,
-    St::Digest: manifest_state::IsSet,
     St::CreatedAt: manifest_state::IsSet,
+    St::MediaType: manifest_state::IsSet,
     St::SchemaVersion: manifest_state::IsSet,
+    St::Digest: manifest_state::IsSet,
+    St::Repository: manifest_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Manifest<S> {
@@ -1484,51 +1484,51 @@ pub mod manifest_reference_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Digest;
         type MediaType;
         type Size;
-        type Digest;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Digest = Unset;
         type MediaType = Unset;
         type Size = Unset;
-        type Digest = Unset;
+    }
+    ///State transition - sets the `digest` field to Set
+    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDigest<St> {}
+    impl<St: State> State for SetDigest<St> {
+        type Digest = Set<members::digest>;
+        type MediaType = St::MediaType;
+        type Size = St::Size;
     }
     ///State transition - sets the `media_type` field to Set
     pub struct SetMediaType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMediaType<St> {}
     impl<St: State> State for SetMediaType<St> {
+        type Digest = St::Digest;
         type MediaType = Set<members::media_type>;
         type Size = St::Size;
-        type Digest = St::Digest;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type MediaType = St::MediaType;
-        type Size = Set<members::size>;
         type Digest = St::Digest;
-    }
-    ///State transition - sets the `digest` field to Set
-    pub struct SetDigest<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDigest<St> {}
-    impl<St: State> State for SetDigest<St> {
         type MediaType = St::MediaType;
-        type Size = St::Size;
-        type Digest = Set<members::digest>;
+        type Size = Set<members::size>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `digest` field
+        pub struct digest(());
         ///Marker type for the `media_type` field
         pub struct media_type(());
         ///Marker type for the `size` field
         pub struct size(());
-        ///Marker type for the `digest` field
-        pub struct digest(());
     }
 }
 
@@ -1649,9 +1649,9 @@ where
 impl<S: BosStr, St> ManifestReferenceBuilder<S, St>
 where
     St: manifest_reference_state::State,
+    St::Digest: manifest_reference_state::IsSet,
     St::MediaType: manifest_reference_state::IsSet,
     St::Size: manifest_reference_state::IsSet,
-    St::Digest: manifest_reference_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ManifestReference<S> {
diff --git a/crates/jacquard-api/src/io_atcr/repo/page.rs b/crates/jacquard-api/src/io_atcr/repo/page.rs
index e6b6010e..9f8b2990 100644
--- a/crates/jacquard-api/src/io_atcr/repo/page.rs
+++ b/crates/jacquard-api/src/io_atcr/repo/page.rs
@@ -185,51 +185,51 @@ pub mod page_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type UpdatedAt;
         type CreatedAt;
         type Repository;
+        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type UpdatedAt = Unset;
         type CreatedAt = Unset;
         type Repository = Unset;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type UpdatedAt = Set<members::updated_at>;
-        type CreatedAt = St::CreatedAt;
-        type Repository = St::Repository;
+        type UpdatedAt = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type UpdatedAt = St::UpdatedAt;
         type CreatedAt = Set<members::created_at>;
         type Repository = St::Repository;
+        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `repository` field to Set
     pub struct SetRepository<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepository<St> {}
     impl<St: State> State for SetRepository<St> {
-        type UpdatedAt = St::UpdatedAt;
         type CreatedAt = St::CreatedAt;
         type Repository = Set<members::repository>;
+        type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type CreatedAt = St::CreatedAt;
+        type Repository = St::Repository;
+        type UpdatedAt = Set<members::updated_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `repository` field
         pub struct repository(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
     }
 }
 
@@ -350,9 +350,9 @@ where
 impl<S: BosStr, St> PageBuilder<S, St>
 where
     St: page_state::State,
-    St::UpdatedAt: page_state::IsSet,
     St::CreatedAt: page_state::IsSet,
     St::Repository: page_state::IsSet,
+    St::UpdatedAt: page_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Page<S> {
diff --git a/crates/jacquard-api/src/io_atcr/sailor/star.rs b/crates/jacquard-api/src/io_atcr/sailor/star.rs
index e7469b0f..091aa41d 100644
--- a/crates/jacquard-api/src/io_atcr/sailor/star.rs
+++ b/crates/jacquard-api/src/io_atcr/sailor/star.rs
@@ -114,37 +114,37 @@ pub mod star_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> StarBuilder<S, St>
 where
     St: star_state::State,
-    St::CreatedAt: star_state::IsSet,
     St::Subject: star_state::IsSet,
+    St::CreatedAt: star_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Star<S> {
diff --git a/crates/jacquard-api/src/io_atcr/sailor/webhook.rs b/crates/jacquard-api/src/io_atcr/sailor/webhook.rs
index 96b40c83..954e9962 100644
--- a/crates/jacquard-api/src/io_atcr/sailor/webhook.rs
+++ b/crates/jacquard-api/src/io_atcr/sailor/webhook.rs
@@ -142,67 +142,67 @@ pub mod webhook_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type HoldDid;
         type Triggers;
         type CreatedAt;
         type PrivateCid;
-        type HoldDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type HoldDid = Unset;
         type Triggers = Unset;
         type CreatedAt = Unset;
         type PrivateCid = Unset;
-        type HoldDid = Unset;
+    }
+    ///State transition - sets the `hold_did` field to Set
+    pub struct SetHoldDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHoldDid<St> {}
+    impl<St: State> State for SetHoldDid<St> {
+        type HoldDid = Set<members::hold_did>;
+        type Triggers = St::Triggers;
+        type CreatedAt = St::CreatedAt;
+        type PrivateCid = St::PrivateCid;
     }
     ///State transition - sets the `triggers` field to Set
     pub struct SetTriggers<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTriggers<St> {}
     impl<St: State> State for SetTriggers<St> {
+        type HoldDid = St::HoldDid;
         type Triggers = Set<members::triggers>;
         type CreatedAt = St::CreatedAt;
         type PrivateCid = St::PrivateCid;
-        type HoldDid = St::HoldDid;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type HoldDid = St::HoldDid;
         type Triggers = St::Triggers;
         type CreatedAt = Set<members::created_at>;
         type PrivateCid = St::PrivateCid;
-        type HoldDid = St::HoldDid;
     }
     ///State transition - sets the `private_cid` field to Set
     pub struct SetPrivateCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPrivateCid<St> {}
     impl<St: State> State for SetPrivateCid<St> {
-        type Triggers = St::Triggers;
-        type CreatedAt = St::CreatedAt;
-        type PrivateCid = Set<members::private_cid>;
         type HoldDid = St::HoldDid;
-    }
-    ///State transition - sets the `hold_did` field to Set
-    pub struct SetHoldDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHoldDid<St> {}
-    impl<St: State> State for SetHoldDid<St> {
         type Triggers = St::Triggers;
         type CreatedAt = St::CreatedAt;
-        type PrivateCid = St::PrivateCid;
-        type HoldDid = Set<members::hold_did>;
+        type PrivateCid = Set<members::private_cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `hold_did` field
+        pub struct hold_did(());
         ///Marker type for the `triggers` field
         pub struct triggers(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `private_cid` field
         pub struct private_cid(());
-        ///Marker type for the `hold_did` field
-        pub struct hold_did(());
     }
 }
 
@@ -329,10 +329,10 @@ impl<S: BosStr, St: webhook_state::State> WebhookBuilder<S, St> {
 impl<S: BosStr, St> WebhookBuilder<S, St>
 where
     St: webhook_state::State,
+    St::HoldDid: webhook_state::IsSet,
     St::Triggers: webhook_state::IsSet,
     St::CreatedAt: webhook_state::IsSet,
     St::PrivateCid: webhook_state::IsSet,
-    St::HoldDid: webhook_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Webhook<S> {
diff --git a/crates/jacquard-api/src/io_kich/cookinglog.rs b/crates/jacquard-api/src/io_kich/cookinglog.rs
index efa1d8f4..6a4c6035 100644
--- a/crates/jacquard-api/src/io_kich/cookinglog.rs
+++ b/crates/jacquard-api/src/io_kich/cookinglog.rs
@@ -130,37 +130,37 @@ pub mod cookinglog_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -256,8 +256,8 @@ where
 impl<S: BosStr, St> CookinglogBuilder<S, St>
 where
     St: cookinglog_state::State,
-    St::Subject: cookinglog_state::IsSet,
     St::CreatedAt: cookinglog_state::IsSet,
+    St::Subject: cookinglog_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Cookinglog<S> {
diff --git a/crates/jacquard-api/src/io_kich/recipe/collection.rs b/crates/jacquard-api/src/io_kich/recipe/collection.rs
index 96c0860e..5543ba1b 100644
--- a/crates/jacquard-api/src/io_kich/recipe/collection.rs
+++ b/crates/jacquard-api/src/io_kich/recipe/collection.rs
@@ -181,37 +181,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -326,8 +326,8 @@ impl<S: BosStr, St: collection_state::State> CollectionBuilder<S, St> {
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::Name: collection_state::IsSet,
     St::CreatedAt: collection_state::IsSet,
+    St::Name: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/io_kich/recipe/collectionfollow.rs b/crates/jacquard-api/src/io_kich/recipe/collectionfollow.rs
index f1c52df1..f530fa8b 100644
--- a/crates/jacquard-api/src/io_kich/recipe/collectionfollow.rs
+++ b/crates/jacquard-api/src/io_kich/recipe/collectionfollow.rs
@@ -114,37 +114,37 @@ pub mod collectionfollow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> CollectionfollowBuilder<S, St>
 where
     St: collectionfollow_state::State,
-    St::Subject: collectionfollow_state::IsSet,
     St::CreatedAt: collectionfollow_state::IsSet,
+    St::Subject: collectionfollow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collectionfollow<S> {
diff --git a/crates/jacquard-api/src/io_kich/recipe/collectionitem.rs b/crates/jacquard-api/src/io_kich/recipe/collectionitem.rs
index 129aaf1f..e5bf860c 100644
--- a/crates/jacquard-api/src/io_kich/recipe/collectionitem.rs
+++ b/crates/jacquard-api/src/io_kich/recipe/collectionitem.rs
@@ -122,51 +122,51 @@ pub mod collectionitem_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
-        type CreatedAt;
         type Collection;
+        type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
-        type CreatedAt = Unset;
         type Collection = Unset;
+        type CreatedAt = Unset;
+        type Subject = Unset;
     }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Collection = Set<members::collection>;
         type CreatedAt = St::CreatedAt;
-        type Collection = St::Collection;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
         type Collection = St::Collection;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
+        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Collection = St::Collection;
         type CreatedAt = St::CreatedAt;
-        type Collection = Set<members::collection>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `collection` field
         pub struct collection(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -287,9 +287,9 @@ where
 impl<S: BosStr, St> CollectionitemBuilder<S, St>
 where
     St: collectionitem_state::State,
-    St::Subject: collectionitem_state::IsSet,
-    St::CreatedAt: collectionitem_state::IsSet,
     St::Collection: collectionitem_state::IsSet,
+    St::CreatedAt: collectionitem_state::IsSet,
+    St::Subject: collectionitem_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collectionitem<S> {
diff --git a/crates/jacquard-api/src/io_kich/recipe/recipe.rs b/crates/jacquard-api/src/io_kich/recipe/recipe.rs
index 3b9ad7da..3307ed4a 100644
--- a/crates/jacquard-api/src/io_kich/recipe/recipe.rs
+++ b/crates/jacquard-api/src/io_kich/recipe/recipe.rs
@@ -667,51 +667,51 @@ pub mod recipe_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Name;
         type Servings;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Name = Unset;
         type Servings = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+        type Servings = St::Servings;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Servings = St::Servings;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `servings` field to Set
     pub struct SetServings<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetServings<St> {}
     impl<St: State> State for SetServings<St> {
-        type Name = St::Name;
-        type Servings = Set<members::servings>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Name = St::Name;
-        type Servings = St::Servings;
-        type CreatedAt = Set<members::created_at>;
+        type Servings = Set<members::servings>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `servings` field
         pub struct servings(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -1045,9 +1045,9 @@ impl<S: BosStr, St: recipe_state::State> RecipeBuilder<S, St> {
 impl<S: BosStr, St> RecipeBuilder<S, St>
 where
     St: recipe_state::State,
+    St::CreatedAt: recipe_state::IsSet,
     St::Name: recipe_state::IsSet,
     St::Servings: recipe_state::IsSet,
-    St::CreatedAt: recipe_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Recipe<S> {
diff --git a/crates/jacquard-api/src/io_kich/recipe/review.rs b/crates/jacquard-api/src/io_kich/recipe/review.rs
index 29fdaaec..46fba836 100644
--- a/crates/jacquard-api/src/io_kich/recipe/review.rs
+++ b/crates/jacquard-api/src/io_kich/recipe/review.rs
@@ -153,51 +153,51 @@ pub mod review_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
         type Rating;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
         type Rating = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
-        type Rating = St::Rating;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
         type Rating = St::Rating;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `rating` field to Set
     pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRating<St> {}
     impl<St: State> State for SetRating<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = St::Subject;
         type Rating = Set<members::rating>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type Rating = St::Rating;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
         ///Marker type for the `rating` field
         pub struct rating(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -318,9 +318,9 @@ impl<S: BosStr, St: review_state::State> ReviewBuilder<S, St> {
 impl<S: BosStr, St> ReviewBuilder<S, St>
 where
     St: review_state::State,
-    St::CreatedAt: review_state::IsSet,
     St::Subject: review_state::IsSet,
     St::Rating: review_state::IsSet,
+    St::CreatedAt: review_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Review<S> {
diff --git a/crates/jacquard-api/src/io_livewire/p3k/podping00.rs b/crates/jacquard-api/src/io_livewire/p3k/podping00.rs
index 99241294..c81baae0 100644
--- a/crates/jacquard-api/src/io_livewire/p3k/podping00.rs
+++ b/crates/jacquard-api/src/io_livewire/p3k/podping00.rs
@@ -114,37 +114,37 @@ pub mod podping00_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Url;
         type CreatedAt;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Url = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Url = Set<members::url>;
-        type CreatedAt = St::CreatedAt;
+        type Url = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Url = St::Url;
         type CreatedAt = Set<members::created_at>;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type CreatedAt = St::CreatedAt;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> Podping00Builder<S, St>
 where
     St: podping00_state::State,
-    St::Url: podping00_state::IsSet,
     St::CreatedAt: podping00_state::IsSet,
+    St::Url: podping00_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Podping00<S> {
diff --git a/crates/jacquard-api/src/io_whiteley/ATlas/pin.rs b/crates/jacquard-api/src/io_whiteley/ATlas/pin.rs
index 6c4cd3c7..c5cac4b1 100644
--- a/crates/jacquard-api/src/io_whiteley/ATlas/pin.rs
+++ b/crates/jacquard-api/src/io_whiteley/ATlas/pin.rs
@@ -160,85 +160,85 @@ pub mod pin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type PlacedAt;
-        type Latitude;
-        type Longitude;
-        type Did;
         type Description;
+        type Did;
+        type Longitude;
+        type Latitude;
+        type PlacedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type PlacedAt = Unset;
-        type Latitude = Unset;
-        type Longitude = Unset;
-        type Did = Unset;
         type Description = Unset;
+        type Did = Unset;
+        type Longitude = Unset;
+        type Latitude = Unset;
+        type PlacedAt = Unset;
     }
-    ///State transition - sets the `placed_at` field to Set
-    pub struct SetPlacedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlacedAt<St> {}
-    impl<St: State> State for SetPlacedAt<St> {
-        type PlacedAt = Set<members::placed_at>;
-        type Latitude = St::Latitude;
-        type Longitude = St::Longitude;
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Description = Set<members::description>;
         type Did = St::Did;
-        type Description = St::Description;
-    }
-    ///State transition - sets the `latitude` field to Set
-    pub struct SetLatitude<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLatitude<St> {}
-    impl<St: State> State for SetLatitude<St> {
-        type PlacedAt = St::PlacedAt;
-        type Latitude = Set<members::latitude>;
         type Longitude = St::Longitude;
-        type Did = St::Did;
-        type Description = St::Description;
-    }
-    ///State transition - sets the `longitude` field to Set
-    pub struct SetLongitude<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLongitude<St> {}
-    impl<St: State> State for SetLongitude<St> {
-        type PlacedAt = St::PlacedAt;
         type Latitude = St::Latitude;
-        type Longitude = Set<members::longitude>;
-        type Did = St::Did;
-        type Description = St::Description;
+        type PlacedAt = St::PlacedAt;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type PlacedAt = St::PlacedAt;
-        type Latitude = St::Latitude;
-        type Longitude = St::Longitude;
-        type Did = Set<members::did>;
         type Description = St::Description;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
+        type Did = Set<members::did>;
+        type Longitude = St::Longitude;
+        type Latitude = St::Latitude;
         type PlacedAt = St::PlacedAt;
+    }
+    ///State transition - sets the `longitude` field to Set
+    pub struct SetLongitude<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLongitude<St> {}
+    impl<St: State> State for SetLongitude<St> {
+        type Description = St::Description;
+        type Did = St::Did;
+        type Longitude = Set<members::longitude>;
         type Latitude = St::Latitude;
+        type PlacedAt = St::PlacedAt;
+    }
+    ///State transition - sets the `latitude` field to Set
+    pub struct SetLatitude<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLatitude<St> {}
+    impl<St: State> State for SetLatitude<St> {
+        type Description = St::Description;
+        type Did = St::Did;
         type Longitude = St::Longitude;
+        type Latitude = Set<members::latitude>;
+        type PlacedAt = St::PlacedAt;
+    }
+    ///State transition - sets the `placed_at` field to Set
+    pub struct SetPlacedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlacedAt<St> {}
+    impl<St: State> State for SetPlacedAt<St> {
+        type Description = St::Description;
         type Did = St::Did;
-        type Description = Set<members::description>;
+        type Longitude = St::Longitude;
+        type Latitude = St::Latitude;
+        type PlacedAt = Set<members::placed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `placed_at` field
-        pub struct placed_at(());
-        ///Marker type for the `latitude` field
-        pub struct latitude(());
-        ///Marker type for the `longitude` field
-        pub struct longitude(());
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `description` field
         pub struct description(());
+        ///Marker type for the `did` field
+        pub struct did(());
+        ///Marker type for the `longitude` field
+        pub struct longitude(());
+        ///Marker type for the `latitude` field
+        pub struct latitude(());
+        ///Marker type for the `placed_at` field
+        pub struct placed_at(());
     }
 }
 
@@ -385,11 +385,11 @@ impl<S: BosStr, St: pin_state::State> PinBuilder<S, St> {
 impl<S: BosStr, St> PinBuilder<S, St>
 where
     St: pin_state::State,
-    St::PlacedAt: pin_state::IsSet,
-    St::Latitude: pin_state::IsSet,
-    St::Longitude: pin_state::IsSet,
-    St::Did: pin_state::IsSet,
     St::Description: pin_state::IsSet,
+    St::Did: pin_state::IsSet,
+    St::Longitude: pin_state::IsSet,
+    St::Latitude: pin_state::IsSet,
+    St::PlacedAt: pin_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Pin<S> {
diff --git a/crates/jacquard-api/src/io_whiteley/luke/ATlas/pin.rs b/crates/jacquard-api/src/io_whiteley/luke/ATlas/pin.rs
index 335cca2d..ac704285 100644
--- a/crates/jacquard-api/src/io_whiteley/luke/ATlas/pin.rs
+++ b/crates/jacquard-api/src/io_whiteley/luke/ATlas/pin.rs
@@ -160,9 +160,9 @@ pub mod pin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Longitude;
         type Description;
+        type Did;
         type Latitude;
         type PlacedAt;
     }
@@ -170,29 +170,19 @@ pub mod pin_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Longitude = Unset;
         type Description = Unset;
+        type Did = Unset;
         type Latitude = Unset;
         type PlacedAt = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Longitude = St::Longitude;
-        type Description = St::Description;
-        type Latitude = St::Latitude;
-        type PlacedAt = St::PlacedAt;
-    }
     ///State transition - sets the `longitude` field to Set
     pub struct SetLongitude<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLongitude<St> {}
     impl<St: State> State for SetLongitude<St> {
-        type Did = St::Did;
         type Longitude = Set<members::longitude>;
         type Description = St::Description;
+        type Did = St::Did;
         type Latitude = St::Latitude;
         type PlacedAt = St::PlacedAt;
     }
@@ -200,9 +190,19 @@ pub mod pin_state {
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type Did = St::Did;
         type Longitude = St::Longitude;
         type Description = Set<members::description>;
+        type Did = St::Did;
+        type Latitude = St::Latitude;
+        type PlacedAt = St::PlacedAt;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Longitude = St::Longitude;
+        type Description = St::Description;
+        type Did = Set<members::did>;
         type Latitude = St::Latitude;
         type PlacedAt = St::PlacedAt;
     }
@@ -210,9 +210,9 @@ pub mod pin_state {
     pub struct SetLatitude<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLatitude<St> {}
     impl<St: State> State for SetLatitude<St> {
-        type Did = St::Did;
         type Longitude = St::Longitude;
         type Description = St::Description;
+        type Did = St::Did;
         type Latitude = Set<members::latitude>;
         type PlacedAt = St::PlacedAt;
     }
@@ -220,21 +220,21 @@ pub mod pin_state {
     pub struct SetPlacedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlacedAt<St> {}
     impl<St: State> State for SetPlacedAt<St> {
-        type Did = St::Did;
         type Longitude = St::Longitude;
         type Description = St::Description;
+        type Did = St::Did;
         type Latitude = St::Latitude;
         type PlacedAt = Set<members::placed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `longitude` field
         pub struct longitude(());
         ///Marker type for the `description` field
         pub struct description(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `latitude` field
         pub struct latitude(());
         ///Marker type for the `placed_at` field
@@ -385,9 +385,9 @@ impl<S: BosStr, St: pin_state::State> PinBuilder<S, St> {
 impl<S: BosStr, St> PinBuilder<S, St>
 where
     St: pin_state::State,
-    St::Did: pin_state::IsSet,
     St::Longitude: pin_state::IsSet,
     St::Description: pin_state::IsSet,
+    St::Did: pin_state::IsSet,
     St::Latitude: pin_state::IsSet,
     St::PlacedAt: pin_state::IsSet,
 {
diff --git a/crates/jacquard-api/src/io_whiteside/linked_account.rs b/crates/jacquard-api/src/io_whiteside/linked_account.rs
index a60c334c..6cb22dcc 100644
--- a/crates/jacquard-api/src/io_whiteside/linked_account.rs
+++ b/crates/jacquard-api/src/io_whiteside/linked_account.rs
@@ -120,50 +120,50 @@ pub mod linked_account_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Link;
-        type Name;
         type Icon;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Link = Unset;
-        type Name = Unset;
         type Icon = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `link` field to Set
     pub struct SetLink<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLink<St> {}
     impl<St: State> State for SetLink<St> {
         type Link = Set<members::link>;
-        type Name = St::Name;
-        type Icon = St::Icon;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Link = St::Link;
-        type Name = Set<members::name>;
         type Icon = St::Icon;
+        type Name = St::Name;
     }
     ///State transition - sets the `icon` field to Set
     pub struct SetIcon<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIcon<St> {}
     impl<St: State> State for SetIcon<St> {
         type Link = St::Link;
-        type Name = St::Name;
         type Icon = Set<members::icon>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Link = St::Link;
+        type Icon = St::Icon;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `link` field
         pub struct link(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `icon` field
         pub struct icon(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -266,8 +266,8 @@ impl<S: BosStr, St> LinkedAccountBuilder<S, St>
 where
     St: linked_account_state::State,
     St::Link: linked_account_state::IsSet,
-    St::Name: linked_account_state::IsSet,
     St::Icon: linked_account_state::IsSet,
+    St::Name: linked_account_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LinkedAccount<S> {
diff --git a/crates/jacquard-api/src/io_whiteside/profile.rs b/crates/jacquard-api/src/io_whiteside/profile.rs
index 8b6096e4..ffee6050 100644
--- a/crates/jacquard-api/src/io_whiteside/profile.rs
+++ b/crates/jacquard-api/src/io_whiteside/profile.rs
@@ -139,50 +139,50 @@ pub mod profile_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Heading;
-        type UpdatedAt;
         type Content;
+        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Heading = Unset;
-        type UpdatedAt = Unset;
         type Content = Unset;
+        type UpdatedAt = Unset;
     }
     ///State transition - sets the `heading` field to Set
     pub struct SetHeading<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeading<St> {}
     impl<St: State> State for SetHeading<St> {
         type Heading = Set<members::heading>;
-        type UpdatedAt = St::UpdatedAt;
-        type Content = St::Content;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type Heading = St::Heading;
-        type UpdatedAt = Set<members::updated_at>;
         type Content = St::Content;
+        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
         type Heading = St::Heading;
-        type UpdatedAt = St::UpdatedAt;
         type Content = Set<members::content>;
+        type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type Heading = St::Heading;
+        type Content = St::Content;
+        type UpdatedAt = Set<members::updated_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `heading` field
         pub struct heading(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
     }
 }
 
@@ -272,8 +272,8 @@ impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
     St::Heading: profile_state::IsSet,
-    St::UpdatedAt: profile_state::IsSet,
     St::Content: profile_state::IsSet,
+    St::UpdatedAt: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
diff --git a/crates/jacquard-api/src/link_bridgebeats/lookup.rs b/crates/jacquard-api/src/link_bridgebeats/lookup.rs
index b4bcdd80..9f2e8634 100644
--- a/crates/jacquard-api/src/link_bridgebeats/lookup.rs
+++ b/crates/jacquard-api/src/link_bridgebeats/lookup.rs
@@ -562,85 +562,85 @@ pub mod provider_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Artist;
-        type Url;
-        type Title;
         type Provider;
         type MarketRegion;
+        type Url;
+        type Artist;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Artist = Unset;
-        type Url = Unset;
-        type Title = Unset;
         type Provider = Unset;
         type MarketRegion = Unset;
+        type Url = Unset;
+        type Artist = Unset;
+        type Title = Unset;
     }
-    ///State transition - sets the `artist` field to Set
-    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtist<St> {}
-    impl<St: State> State for SetArtist<St> {
-        type Artist = Set<members::artist>;
+    ///State transition - sets the `provider` field to Set
+    pub struct SetProvider<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetProvider<St> {}
+    impl<St: State> State for SetProvider<St> {
+        type Provider = Set<members::provider>;
+        type MarketRegion = St::MarketRegion;
         type Url = St::Url;
+        type Artist = St::Artist;
         type Title = St::Title;
+    }
+    ///State transition - sets the `market_region` field to Set
+    pub struct SetMarketRegion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMarketRegion<St> {}
+    impl<St: State> State for SetMarketRegion<St> {
         type Provider = St::Provider;
-        type MarketRegion = St::MarketRegion;
+        type MarketRegion = Set<members::market_region>;
+        type Url = St::Url;
+        type Artist = St::Artist;
+        type Title = St::Title;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type Artist = St::Artist;
+        type Provider = St::Provider;
+        type MarketRegion = St::MarketRegion;
         type Url = Set<members::url>;
+        type Artist = St::Artist;
         type Title = St::Title;
+    }
+    ///State transition - sets the `artist` field to Set
+    pub struct SetArtist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtist<St> {}
+    impl<St: State> State for SetArtist<St> {
         type Provider = St::Provider;
         type MarketRegion = St::MarketRegion;
+        type Url = St::Url;
+        type Artist = Set<members::artist>;
+        type Title = St::Title;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Artist = St::Artist;
-        type Url = St::Url;
-        type Title = Set<members::title>;
         type Provider = St::Provider;
         type MarketRegion = St::MarketRegion;
-    }
-    ///State transition - sets the `provider` field to Set
-    pub struct SetProvider<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetProvider<St> {}
-    impl<St: State> State for SetProvider<St> {
-        type Artist = St::Artist;
         type Url = St::Url;
-        type Title = St::Title;
-        type Provider = Set<members::provider>;
-        type MarketRegion = St::MarketRegion;
-    }
-    ///State transition - sets the `market_region` field to Set
-    pub struct SetMarketRegion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMarketRegion<St> {}
-    impl<St: State> State for SetMarketRegion<St> {
         type Artist = St::Artist;
-        type Url = St::Url;
-        type Title = St::Title;
-        type Provider = St::Provider;
-        type MarketRegion = Set<members::market_region>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artist` field
-        pub struct artist(());
-        ///Marker type for the `url` field
-        pub struct url(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `provider` field
         pub struct provider(());
         ///Marker type for the `market_region` field
         pub struct market_region(());
+        ///Marker type for the `url` field
+        pub struct url(());
+        ///Marker type for the `artist` field
+        pub struct artist(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -815,11 +815,11 @@ where
 impl<S: BosStr, St> ProviderResultBuilder<S, St>
 where
     St: provider_result_state::State,
-    St::Artist: provider_result_state::IsSet,
-    St::Url: provider_result_state::IsSet,
-    St::Title: provider_result_state::IsSet,
     St::Provider: provider_result_state::IsSet,
     St::MarketRegion: provider_result_state::IsSet,
+    St::Url: provider_result_state::IsSet,
+    St::Artist: provider_result_state::IsSet,
+    St::Title: provider_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProviderResult<S> {
diff --git a/crates/jacquard-api/src/me_linkna/lastfm.rs b/crates/jacquard-api/src/me_linkna/lastfm.rs
index 8fdf9360..29b246cd 100644
--- a/crates/jacquard-api/src/me_linkna/lastfm.rs
+++ b/crates/jacquard-api/src/me_linkna/lastfm.rs
@@ -137,49 +137,49 @@ pub mod lastfm_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ArtistNames;
         type TrackName;
+        type ArtistNames;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ArtistNames = Unset;
         type TrackName = Unset;
+        type ArtistNames = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `artist_names` field to Set
-    pub struct SetArtistNames<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetArtistNames<St> {}
-    impl<St: State> State for SetArtistNames<St> {
-        type ArtistNames = Set<members::artist_names>;
-        type TrackName = St::TrackName;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `track_name` field to Set
     pub struct SetTrackName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTrackName<St> {}
     impl<St: State> State for SetTrackName<St> {
-        type ArtistNames = St::ArtistNames;
         type TrackName = Set<members::track_name>;
+        type ArtistNames = St::ArtistNames;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `artist_names` field to Set
+    pub struct SetArtistNames<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetArtistNames<St> {}
+    impl<St: State> State for SetArtistNames<St> {
+        type TrackName = St::TrackName;
+        type ArtistNames = Set<members::artist_names>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type ArtistNames = St::ArtistNames;
         type TrackName = St::TrackName;
+        type ArtistNames = St::ArtistNames;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `artist_names` field
-        pub struct artist_names(());
         ///Marker type for the `track_name` field
         pub struct track_name(());
+        ///Marker type for the `artist_names` field
+        pub struct artist_names(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -372,8 +372,8 @@ where
 impl<S: BosStr, St> LastfmBuilder<S, St>
 where
     St: lastfm_state::State,
-    St::ArtistNames: lastfm_state::IsSet,
     St::TrackName: lastfm_state::IsSet,
+    St::ArtistNames: lastfm_state::IsSet,
     St::CreatedAt: lastfm_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/me_linkna/linkinbio.rs b/crates/jacquard-api/src/me_linkna/linkinbio.rs
index dfd53bb7..1aeb9f86 100644
--- a/crates/jacquard-api/src/me_linkna/linkinbio.rs
+++ b/crates/jacquard-api/src/me_linkna/linkinbio.rs
@@ -2795,50 +2795,50 @@ pub mod github_contribution_day_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Level;
-        type Date;
         type Count;
+        type Date;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Level = Unset;
-        type Date = Unset;
         type Count = Unset;
+        type Date = Unset;
     }
     ///State transition - sets the `level` field to Set
     pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLevel<St> {}
     impl<St: State> State for SetLevel<St> {
         type Level = Set<members::level>;
-        type Date = St::Date;
-        type Count = St::Count;
-    }
-    ///State transition - sets the `date` field to Set
-    pub struct SetDate<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDate<St> {}
-    impl<St: State> State for SetDate<St> {
-        type Level = St::Level;
-        type Date = Set<members::date>;
         type Count = St::Count;
+        type Date = St::Date;
     }
     ///State transition - sets the `count` field to Set
     pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCount<St> {}
     impl<St: State> State for SetCount<St> {
         type Level = St::Level;
-        type Date = St::Date;
         type Count = Set<members::count>;
+        type Date = St::Date;
+    }
+    ///State transition - sets the `date` field to Set
+    pub struct SetDate<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDate<St> {}
+    impl<St: State> State for SetDate<St> {
+        type Level = St::Level;
+        type Count = St::Count;
+        type Date = Set<members::date>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `level` field
         pub struct level(());
-        ///Marker type for the `date` field
-        pub struct date(());
         ///Marker type for the `count` field
         pub struct count(());
+        ///Marker type for the `date` field
+        pub struct date(());
     }
 }
 
@@ -2934,8 +2934,8 @@ impl<S: BosStr, St> GithubContributionDayBuilder<S, St>
 where
     St: github_contribution_day_state::State,
     St::Level: github_contribution_day_state::IsSet,
-    St::Date: github_contribution_day_state::IsSet,
     St::Count: github_contribution_day_state::IsSet,
+    St::Date: github_contribution_day_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GithubContributionDay<S> {
@@ -3155,50 +3155,50 @@ pub mod social_icon_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Id;
-        type Url;
         type Platform;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Id = Unset;
-        type Url = Unset;
         type Platform = Unset;
+        type Url = Unset;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
         type Id = Set<members::id>;
-        type Url = St::Url;
-        type Platform = St::Platform;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Id = St::Id;
-        type Url = Set<members::url>;
         type Platform = St::Platform;
+        type Url = St::Url;
     }
     ///State transition - sets the `platform` field to Set
     pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlatform<St> {}
     impl<St: State> State for SetPlatform<St> {
         type Id = St::Id;
-        type Url = St::Url;
         type Platform = Set<members::platform>;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Id = St::Id;
+        type Platform = St::Platform;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `platform` field
         pub struct platform(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -3288,8 +3288,8 @@ impl<S: BosStr, St> SocialIconBuilder<S, St>
 where
     St: social_icon_state::State,
     St::Id: social_icon_state::IsSet,
-    St::Url: social_icon_state::IsSet,
     St::Platform: social_icon_state::IsSet,
+    St::Url: social_icon_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SocialIcon<S> {
@@ -3324,67 +3324,67 @@ pub mod widget_github_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Contributions;
         type Id;
-        type GithubUsername;
         type Type;
+        type Contributions;
+        type GithubUsername;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Contributions = Unset;
         type Id = Unset;
-        type GithubUsername = Unset;
         type Type = Unset;
-    }
-    ///State transition - sets the `contributions` field to Set
-    pub struct SetContributions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContributions<St> {}
-    impl<St: State> State for SetContributions<St> {
-        type Contributions = Set<members::contributions>;
-        type Id = St::Id;
-        type GithubUsername = St::GithubUsername;
-        type Type = St::Type;
+        type Contributions = Unset;
+        type GithubUsername = Unset;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Contributions = St::Contributions;
         type Id = Set<members::id>;
-        type GithubUsername = St::GithubUsername;
         type Type = St::Type;
-    }
-    ///State transition - sets the `github_username` field to Set
-    pub struct SetGithubUsername<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGithubUsername<St> {}
-    impl<St: State> State for SetGithubUsername<St> {
         type Contributions = St::Contributions;
-        type Id = St::Id;
-        type GithubUsername = Set<members::github_username>;
-        type Type = St::Type;
+        type GithubUsername = St::GithubUsername;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
+        type Id = St::Id;
+        type Type = Set<members::r#type>;
         type Contributions = St::Contributions;
+        type GithubUsername = St::GithubUsername;
+    }
+    ///State transition - sets the `contributions` field to Set
+    pub struct SetContributions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContributions<St> {}
+    impl<St: State> State for SetContributions<St> {
         type Id = St::Id;
+        type Type = St::Type;
+        type Contributions = Set<members::contributions>;
         type GithubUsername = St::GithubUsername;
-        type Type = Set<members::r#type>;
+    }
+    ///State transition - sets the `github_username` field to Set
+    pub struct SetGithubUsername<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGithubUsername<St> {}
+    impl<St: State> State for SetGithubUsername<St> {
+        type Id = St::Id;
+        type Type = St::Type;
+        type Contributions = St::Contributions;
+        type GithubUsername = Set<members::github_username>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `contributions` field
-        pub struct contributions(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `github_username` field
-        pub struct github_username(());
         ///Marker type for the `type` field
         pub struct r#type(());
+        ///Marker type for the `contributions` field
+        pub struct contributions(());
+        ///Marker type for the `github_username` field
+        pub struct github_username(());
     }
 }
 
@@ -3553,10 +3553,10 @@ where
 impl<S: BosStr, St> WidgetGithubBuilder<S, St>
 where
     St: widget_github_state::State,
-    St::Contributions: widget_github_state::IsSet,
     St::Id: widget_github_state::IsSet,
-    St::GithubUsername: widget_github_state::IsSet,
     St::Type: widget_github_state::IsSet,
+    St::Contributions: widget_github_state::IsSet,
+    St::GithubUsername: widget_github_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WidgetGithub<S> {
@@ -3601,85 +3601,85 @@ pub mod widget_goodreads_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Shelf;
-        type Id;
         type GoodreadsUserId;
-        type Type;
+        type Id;
+        type Shelf;
         type Books;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Shelf = Unset;
-        type Id = Unset;
         type GoodreadsUserId = Unset;
-        type Type = Unset;
+        type Id = Unset;
+        type Shelf = Unset;
         type Books = Unset;
+        type Type = Unset;
     }
-    ///State transition - sets the `shelf` field to Set
-    pub struct SetShelf<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetShelf<St> {}
-    impl<St: State> State for SetShelf<St> {
-        type Shelf = Set<members::shelf>;
+    ///State transition - sets the `goodreads_user_id` field to Set
+    pub struct SetGoodreadsUserId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGoodreadsUserId<St> {}
+    impl<St: State> State for SetGoodreadsUserId<St> {
+        type GoodreadsUserId = Set<members::goodreads_user_id>;
         type Id = St::Id;
-        type GoodreadsUserId = St::GoodreadsUserId;
-        type Type = St::Type;
+        type Shelf = St::Shelf;
         type Books = St::Books;
+        type Type = St::Type;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Shelf = St::Shelf;
-        type Id = Set<members::id>;
         type GoodreadsUserId = St::GoodreadsUserId;
-        type Type = St::Type;
-        type Books = St::Books;
-    }
-    ///State transition - sets the `goodreads_user_id` field to Set
-    pub struct SetGoodreadsUserId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGoodreadsUserId<St> {}
-    impl<St: State> State for SetGoodreadsUserId<St> {
+        type Id = Set<members::id>;
         type Shelf = St::Shelf;
-        type Id = St::Id;
-        type GoodreadsUserId = Set<members::goodreads_user_id>;
-        type Type = St::Type;
         type Books = St::Books;
+        type Type = St::Type;
     }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Shelf = St::Shelf;
-        type Id = St::Id;
+    ///State transition - sets the `shelf` field to Set
+    pub struct SetShelf<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetShelf<St> {}
+    impl<St: State> State for SetShelf<St> {
         type GoodreadsUserId = St::GoodreadsUserId;
-        type Type = Set<members::r#type>;
+        type Id = St::Id;
+        type Shelf = Set<members::shelf>;
         type Books = St::Books;
+        type Type = St::Type;
     }
     ///State transition - sets the `books` field to Set
     pub struct SetBooks<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBooks<St> {}
     impl<St: State> State for SetBooks<St> {
-        type Shelf = St::Shelf;
-        type Id = St::Id;
         type GoodreadsUserId = St::GoodreadsUserId;
-        type Type = St::Type;
+        type Id = St::Id;
+        type Shelf = St::Shelf;
         type Books = Set<members::books>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type GoodreadsUserId = St::GoodreadsUserId;
+        type Id = St::Id;
+        type Shelf = St::Shelf;
+        type Books = St::Books;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `shelf` field
-        pub struct shelf(());
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `goodreads_user_id` field
         pub struct goodreads_user_id(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
+        ///Marker type for the `id` field
+        pub struct id(());
+        ///Marker type for the `shelf` field
+        pub struct shelf(());
         ///Marker type for the `books` field
         pub struct books(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -3874,11 +3874,11 @@ where
 impl<S: BosStr, St> WidgetGoodreadsBuilder<S, St>
 where
     St: widget_goodreads_state::State,
-    St::Shelf: widget_goodreads_state::IsSet,
-    St::Id: widget_goodreads_state::IsSet,
     St::GoodreadsUserId: widget_goodreads_state::IsSet,
-    St::Type: widget_goodreads_state::IsSet,
+    St::Id: widget_goodreads_state::IsSet,
+    St::Shelf: widget_goodreads_state::IsSet,
     St::Books: widget_goodreads_state::IsSet,
+    St::Type: widget_goodreads_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WidgetGoodreads<S> {
diff --git a/crates/jacquard-api/src/media_ionosphere.rs b/crates/jacquard-api/src/media_ionosphere.rs
index 5b1a8200..a35acccf 100644
--- a/crates/jacquard-api/src/media_ionosphere.rs
+++ b/crates/jacquard-api/src/media_ionosphere.rs
@@ -1304,37 +1304,37 @@ pub mod track_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Artists;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Artists = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Artists = St::Artists;
+        type Title = Unset;
     }
     ///State transition - sets the `artists` field to Set
     pub struct SetArtists<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetArtists<St> {}
     impl<St: State> State for SetArtists<St> {
-        type Title = St::Title;
         type Artists = Set<members::artists>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Artists = St::Artists;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `artists` field
         pub struct artists(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -1417,8 +1417,8 @@ where
 impl<S: BosStr, St> TrackBuilder<S, St>
 where
     St: track_state::State,
-    St::Title: track_state::IsSet,
     St::Artists: track_state::IsSet,
+    St::Title: track_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Track<S> {
diff --git a/crates/jacquard-api/src/media_ionosphere/group.rs b/crates/jacquard-api/src/media_ionosphere/group.rs
index 14e6c8c6..9cb64361 100644
--- a/crates/jacquard-api/src/media_ionosphere/group.rs
+++ b/crates/jacquard-api/src/media_ionosphere/group.rs
@@ -302,50 +302,50 @@ pub mod group_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Ionosphere;
-        type Language;
         type Name;
+        type Language;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Ionosphere = Unset;
-        type Language = Unset;
         type Name = Unset;
+        type Language = Unset;
     }
     ///State transition - sets the `ionosphere` field to Set
     pub struct SetIonosphere<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIonosphere<St> {}
     impl<St: State> State for SetIonosphere<St> {
         type Ionosphere = Set<members::ionosphere>;
-        type Language = St::Language;
-        type Name = St::Name;
-    }
-    ///State transition - sets the `language` field to Set
-    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLanguage<St> {}
-    impl<St: State> State for SetLanguage<St> {
-        type Ionosphere = St::Ionosphere;
-        type Language = Set<members::language>;
         type Name = St::Name;
+        type Language = St::Language;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type Ionosphere = St::Ionosphere;
-        type Language = St::Language;
         type Name = Set<members::name>;
+        type Language = St::Language;
+    }
+    ///State transition - sets the `language` field to Set
+    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLanguage<St> {}
+    impl<St: State> State for SetLanguage<St> {
+        type Ionosphere = St::Ionosphere;
+        type Name = St::Name;
+        type Language = Set<members::language>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `ionosphere` field
         pub struct ionosphere(());
-        ///Marker type for the `language` field
-        pub struct language(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `language` field
+        pub struct language(());
     }
 }
 
@@ -523,8 +523,8 @@ impl<S: BosStr, St> GroupBuilder<S, St>
 where
     St: group_state::State,
     St::Ionosphere: group_state::IsSet,
-    St::Language: group_state::IsSet,
     St::Name: group_state::IsSet,
+    St::Language: group_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Group<S> {
diff --git a/crates/jacquard-api/src/media_ionosphere/programme.rs b/crates/jacquard-api/src/media_ionosphere/programme.rs
index 766a3d5f..6179630d 100644
--- a/crates/jacquard-api/src/media_ionosphere/programme.rs
+++ b/crates/jacquard-api/src/media_ionosphere/programme.rs
@@ -208,49 +208,49 @@ pub mod programme_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Language;
         type Name;
+        type Language;
         type Ionosphere;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Language = Unset;
         type Name = Unset;
+        type Language = Unset;
         type Ionosphere = Unset;
     }
-    ///State transition - sets the `language` field to Set
-    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLanguage<St> {}
-    impl<St: State> State for SetLanguage<St> {
-        type Language = Set<members::language>;
-        type Name = St::Name;
-        type Ionosphere = St::Ionosphere;
-    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Language = St::Language;
         type Name = Set<members::name>;
+        type Language = St::Language;
+        type Ionosphere = St::Ionosphere;
+    }
+    ///State transition - sets the `language` field to Set
+    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLanguage<St> {}
+    impl<St: State> State for SetLanguage<St> {
+        type Name = St::Name;
+        type Language = Set<members::language>;
         type Ionosphere = St::Ionosphere;
     }
     ///State transition - sets the `ionosphere` field to Set
     pub struct SetIonosphere<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIonosphere<St> {}
     impl<St: State> State for SetIonosphere<St> {
-        type Language = St::Language;
         type Name = St::Name;
+        type Language = St::Language;
         type Ionosphere = Set<members::ionosphere>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `language` field
-        pub struct language(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `language` field
+        pub struct language(());
         ///Marker type for the `ionosphere` field
         pub struct ionosphere(());
     }
@@ -463,8 +463,8 @@ impl<S: BosStr, St: programme_state::State> ProgrammeBuilder<S, St> {
 impl<S: BosStr, St> ProgrammeBuilder<S, St>
 where
     St: programme_state::State,
-    St::Language: programme_state::IsSet,
     St::Name: programme_state::IsSet,
+    St::Language: programme_state::IsSet,
     St::Ionosphere: programme_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/media_ionosphere/service.rs b/crates/jacquard-api/src/media_ionosphere/service.rs
index 157ef5f9..26c12027 100644
--- a/crates/jacquard-api/src/media_ionosphere/service.rs
+++ b/crates/jacquard-api/src/media_ionosphere/service.rs
@@ -195,50 +195,50 @@ pub mod service_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Language;
-        type Ionosphere;
         type Name;
+        type Ionosphere;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Language = Unset;
-        type Ionosphere = Unset;
         type Name = Unset;
+        type Ionosphere = Unset;
     }
     ///State transition - sets the `language` field to Set
     pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLanguage<St> {}
     impl<St: State> State for SetLanguage<St> {
         type Language = Set<members::language>;
-        type Ionosphere = St::Ionosphere;
-        type Name = St::Name;
-    }
-    ///State transition - sets the `ionosphere` field to Set
-    pub struct SetIonosphere<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIonosphere<St> {}
-    impl<St: State> State for SetIonosphere<St> {
-        type Language = St::Language;
-        type Ionosphere = Set<members::ionosphere>;
         type Name = St::Name;
+        type Ionosphere = St::Ionosphere;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type Language = St::Language;
-        type Ionosphere = St::Ionosphere;
         type Name = Set<members::name>;
+        type Ionosphere = St::Ionosphere;
+    }
+    ///State transition - sets the `ionosphere` field to Set
+    pub struct SetIonosphere<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIonosphere<St> {}
+    impl<St: State> State for SetIonosphere<St> {
+        type Language = St::Language;
+        type Name = St::Name;
+        type Ionosphere = Set<members::ionosphere>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `language` field
         pub struct language(());
-        ///Marker type for the `ionosphere` field
-        pub struct ionosphere(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `ionosphere` field
+        pub struct ionosphere(());
     }
 }
 
@@ -430,8 +430,8 @@ impl<S: BosStr, St> ServiceBuilder<S, St>
 where
     St: service_state::State,
     St::Language: service_state::IsSet,
-    St::Ionosphere: service_state::IsSet,
     St::Name: service_state::IsSet,
+    St::Ionosphere: service_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Service<S> {
diff --git a/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs b/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs
index 8084676c..f577a626 100644
--- a/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs
+++ b/crates/jacquard-api/src/net_aftertheinter/coolthingtwo.rs
@@ -146,37 +146,37 @@ pub mod coolthingtwo_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type CreatedAt;
+        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type CreatedAt = St::CreatedAt;
+        type Status = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Status = St::Status;
         type CreatedAt = Set<members::created_at>;
+        type Status = St::Status;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type CreatedAt = St::CreatedAt;
+        type Status = Set<members::status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
     }
 }
 
@@ -246,8 +246,8 @@ where
 impl<S: BosStr, St> CoolthingtwoBuilder<S, St>
 where
     St: coolthingtwo_state::State,
-    St::Status: coolthingtwo_state::IsSet,
     St::CreatedAt: coolthingtwo_state::IsSet,
+    St::Status: coolthingtwo_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Coolthingtwo<S> {
diff --git a/crates/jacquard-api/src/net_alternativeproto/review.rs b/crates/jacquard-api/src/net_alternativeproto/review.rs
index 3ca59b30..5b97df13 100644
--- a/crates/jacquard-api/src/net_alternativeproto/review.rs
+++ b/crates/jacquard-api/src/net_alternativeproto/review.rs
@@ -164,8 +164,8 @@ pub mod review_state {
     pub trait State: sealed::Sealed {
         type Rating;
         type ProjectId;
-        type Text;
         type CreatedAt;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -173,8 +173,8 @@ pub mod review_state {
     impl State for Empty {
         type Rating = Unset;
         type ProjectId = Unset;
-        type Text = Unset;
         type CreatedAt = Unset;
+        type Text = Unset;
     }
     ///State transition - sets the `rating` field to Set
     pub struct SetRating<St: State = Empty>(PhantomData<fn() -> St>);
@@ -182,8 +182,8 @@ pub mod review_state {
     impl<St: State> State for SetRating<St> {
         type Rating = Set<members::rating>;
         type ProjectId = St::ProjectId;
-        type Text = St::Text;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `project_id` field to Set
     pub struct SetProjectId<St: State = Empty>(PhantomData<fn() -> St>);
@@ -191,17 +191,8 @@ pub mod review_state {
     impl<St: State> State for SetProjectId<St> {
         type Rating = St::Rating;
         type ProjectId = Set<members::project_id>;
-        type Text = St::Text;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Rating = St::Rating;
-        type ProjectId = St::ProjectId;
-        type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -209,8 +200,17 @@ pub mod review_state {
     impl<St: State> State for SetCreatedAt<St> {
         type Rating = St::Rating;
         type ProjectId = St::ProjectId;
-        type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type Rating = St::Rating;
+        type ProjectId = St::ProjectId;
+        type CreatedAt = St::CreatedAt;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -219,10 +219,10 @@ pub mod review_state {
         pub struct rating(());
         ///Marker type for the `project_id` field
         pub struct project_id(());
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -332,8 +332,8 @@ where
     St: review_state::State,
     St::Rating: review_state::IsSet,
     St::ProjectId: review_state::IsSet,
-    St::Text: review_state::IsSet,
     St::CreatedAt: review_state::IsSet,
+    St::Text: review_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Review<S> {
diff --git a/crates/jacquard-api/src/net_alternativeproto/submission.rs b/crates/jacquard-api/src/net_alternativeproto/submission.rs
index ba413c72..95f50f1d 100644
--- a/crates/jacquard-api/src/net_alternativeproto/submission.rs
+++ b/crates/jacquard-api/src/net_alternativeproto/submission.rs
@@ -291,83 +291,83 @@ pub mod submission_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AuthType;
-        type Url;
         type Name;
+        type AuthType;
         type CreatedAt;
+        type Url;
         type Description;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AuthType = Unset;
-        type Url = Unset;
         type Name = Unset;
+        type AuthType = Unset;
         type CreatedAt = Unset;
+        type Url = Unset;
         type Description = Unset;
     }
-    ///State transition - sets the `auth_type` field to Set
-    pub struct SetAuthType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthType<St> {}
-    impl<St: State> State for SetAuthType<St> {
-        type AuthType = Set<members::auth_type>;
-        type Url = St::Url;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-        type Description = St::Description;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type AuthType = St::AuthType;
-        type Url = Set<members::url>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-        type Description = St::Description;
-    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
         type AuthType = St::AuthType;
+        type CreatedAt = St::CreatedAt;
         type Url = St::Url;
-        type Name = Set<members::name>;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `auth_type` field to Set
+    pub struct SetAuthType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthType<St> {}
+    impl<St: State> State for SetAuthType<St> {
+        type Name = St::Name;
+        type AuthType = Set<members::auth_type>;
         type CreatedAt = St::CreatedAt;
+        type Url = St::Url;
         type Description = St::Description;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
         type AuthType = St::AuthType;
+        type CreatedAt = Set<members::created_at>;
         type Url = St::Url;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
         type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
+        type AuthType = St::AuthType;
+        type CreatedAt = St::CreatedAt;
+        type Url = Set<members::url>;
         type Description = St::Description;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type AuthType = St::AuthType;
-        type Url = St::Url;
         type Name = St::Name;
+        type AuthType = St::AuthType;
         type CreatedAt = St::CreatedAt;
+        type Url = St::Url;
         type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `auth_type` field
-        pub struct auth_type(());
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `auth_type` field
+        pub struct auth_type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `url` field
+        pub struct url(());
         ///Marker type for the `description` field
         pub struct description(());
     }
@@ -572,10 +572,10 @@ where
 impl<S: BosStr, St> SubmissionBuilder<S, St>
 where
     St: submission_state::State,
-    St::AuthType: submission_state::IsSet,
-    St::Url: submission_state::IsSet,
     St::Name: submission_state::IsSet,
+    St::AuthType: submission_state::IsSet,
     St::CreatedAt: submission_state::IsSet,
+    St::Url: submission_state::IsSet,
     St::Description: submission_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_alternativeproto/vote.rs b/crates/jacquard-api/src/net_alternativeproto/vote.rs
index 2cacf427..c5b134a0 100644
--- a/crates/jacquard-api/src/net_alternativeproto/vote.rs
+++ b/crates/jacquard-api/src/net_alternativeproto/vote.rs
@@ -196,51 +196,51 @@ pub mod vote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Subject;
         type Direction;
         type CreatedAt;
-        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Subject = Unset;
         type Direction = Unset;
         type CreatedAt = Unset;
-        type Subject = Unset;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
+        type Direction = St::Direction;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `direction` field to Set
     pub struct SetDirection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDirection<St> {}
     impl<St: State> State for SetDirection<St> {
+        type Subject = St::Subject;
         type Direction = Set<members::direction>;
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Direction = St::Direction;
-        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type Direction = St::Direction;
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `direction` field
         pub struct direction(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
     }
 }
 
@@ -329,9 +329,9 @@ where
 impl<S: BosStr, St> VoteBuilder<S, St>
 where
     St: vote_state::State,
+    St::Subject: vote_state::IsSet,
     St::Direction: vote_state::IsSet,
     St::CreatedAt: vote_state::IsSet,
-    St::Subject: vote_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Vote<S> {
diff --git a/crates/jacquard-api/src/net_altq/aqfile.rs b/crates/jacquard-api/src/net_altq/aqfile.rs
index 2827de20..692523c5 100644
--- a/crates/jacquard-api/src/net_altq/aqfile.rs
+++ b/crates/jacquard-api/src/net_altq/aqfile.rs
@@ -554,37 +554,37 @@ pub mod file_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Size;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Size = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Size = St::Size;
+        type Name = Unset;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type Name = St::Name;
         type Size = Set<members::size>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Size = St::Size;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `size` field
         pub struct size(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -680,8 +680,8 @@ where
 impl<S: BosStr, St> FileBuilder<S, St>
 where
     St: file_state::State,
-    St::Name: file_state::IsSet,
     St::Size: file_state::IsSet,
+    St::Name: file_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> File<S> {
@@ -715,49 +715,49 @@ pub mod aqfile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Blob;
         type CreatedAt;
+        type Blob;
         type File;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Blob = Unset;
         type CreatedAt = Unset;
+        type Blob = Unset;
         type File = Unset;
     }
-    ///State transition - sets the `blob` field to Set
-    pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlob<St> {}
-    impl<St: State> State for SetBlob<St> {
-        type Blob = Set<members::blob>;
-        type CreatedAt = St::CreatedAt;
-        type File = St::File;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Blob = St::Blob;
         type CreatedAt = Set<members::created_at>;
+        type Blob = St::Blob;
+        type File = St::File;
+    }
+    ///State transition - sets the `blob` field to Set
+    pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlob<St> {}
+    impl<St: State> State for SetBlob<St> {
+        type CreatedAt = St::CreatedAt;
+        type Blob = Set<members::blob>;
         type File = St::File;
     }
     ///State transition - sets the `file` field to Set
     pub struct SetFile<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFile<St> {}
     impl<St: State> State for SetFile<St> {
-        type Blob = St::Blob;
         type CreatedAt = St::CreatedAt;
+        type Blob = St::Blob;
         type File = Set<members::file>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `blob` field
-        pub struct blob(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `blob` field
+        pub struct blob(());
         ///Marker type for the `file` field
         pub struct file(());
     }
@@ -880,8 +880,8 @@ where
 impl<S: BosStr, St> AqfileBuilder<S, St>
 where
     St: aqfile_state::State,
-    St::Blob: aqfile_state::IsSet,
     St::CreatedAt: aqfile_state::IsSet,
+    St::Blob: aqfile_state::IsSet,
     St::File: aqfile_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_anisota/beta/game/collection.rs b/crates/jacquard-api/src/net_anisota/beta/game/collection.rs
index 3854e3e8..2983aced 100644
--- a/crates/jacquard-api/src/net_anisota/beta/game/collection.rs
+++ b/crates/jacquard-api/src/net_anisota/beta/game/collection.rs
@@ -294,8 +294,8 @@ pub mod collection_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type AcquiredAt;
-        type Quantity;
         type SpecimenId;
+        type Quantity;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
@@ -303,8 +303,8 @@ pub mod collection_state {
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type AcquiredAt = Unset;
-        type Quantity = Unset;
         type SpecimenId = Unset;
+        type Quantity = Unset;
         type CreatedAt = Unset;
     }
     ///State transition - sets the `acquired_at` field to Set
@@ -312,17 +312,8 @@ pub mod collection_state {
     impl<St: State> sealed::Sealed for SetAcquiredAt<St> {}
     impl<St: State> State for SetAcquiredAt<St> {
         type AcquiredAt = Set<members::acquired_at>;
-        type Quantity = St::Quantity;
-        type SpecimenId = St::SpecimenId;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `quantity` field to Set
-    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuantity<St> {}
-    impl<St: State> State for SetQuantity<St> {
-        type AcquiredAt = St::AcquiredAt;
-        type Quantity = Set<members::quantity>;
         type SpecimenId = St::SpecimenId;
+        type Quantity = St::Quantity;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `specimen_id` field to Set
@@ -330,8 +321,17 @@ pub mod collection_state {
     impl<St: State> sealed::Sealed for SetSpecimenId<St> {}
     impl<St: State> State for SetSpecimenId<St> {
         type AcquiredAt = St::AcquiredAt;
-        type Quantity = St::Quantity;
         type SpecimenId = Set<members::specimen_id>;
+        type Quantity = St::Quantity;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `quantity` field to Set
+    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuantity<St> {}
+    impl<St: State> State for SetQuantity<St> {
+        type AcquiredAt = St::AcquiredAt;
+        type SpecimenId = St::SpecimenId;
+        type Quantity = Set<members::quantity>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
@@ -339,8 +339,8 @@ pub mod collection_state {
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type AcquiredAt = St::AcquiredAt;
-        type Quantity = St::Quantity;
         type SpecimenId = St::SpecimenId;
+        type Quantity = St::Quantity;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
@@ -348,10 +348,10 @@ pub mod collection_state {
     pub mod members {
         ///Marker type for the `acquired_at` field
         pub struct acquired_at(());
-        ///Marker type for the `quantity` field
-        pub struct quantity(());
         ///Marker type for the `specimen_id` field
         pub struct specimen_id(());
+        ///Marker type for the `quantity` field
+        pub struct quantity(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -679,8 +679,8 @@ impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
     St::AcquiredAt: collection_state::IsSet,
-    St::Quantity: collection_state::IsSet,
     St::SpecimenId: collection_state::IsSet,
+    St::Quantity: collection_state::IsSet,
     St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs b/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs
index f812da8f..66429627 100644
--- a/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs
+++ b/crates/jacquard-api/src/net_anisota/beta/game/inventory.rs
@@ -243,67 +243,67 @@ pub mod inventory_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Quantity;
-        type CreatedAt;
         type AcquiredAt;
+        type Quantity;
         type ItemId;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Quantity = Unset;
-        type CreatedAt = Unset;
         type AcquiredAt = Unset;
+        type Quantity = Unset;
         type ItemId = Unset;
-    }
-    ///State transition - sets the `quantity` field to Set
-    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuantity<St> {}
-    impl<St: State> State for SetQuantity<St> {
-        type Quantity = Set<members::quantity>;
-        type CreatedAt = St::CreatedAt;
-        type AcquiredAt = St::AcquiredAt;
-        type ItemId = St::ItemId;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Quantity = St::Quantity;
-        type CreatedAt = Set<members::created_at>;
-        type AcquiredAt = St::AcquiredAt;
-        type ItemId = St::ItemId;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `acquired_at` field to Set
     pub struct SetAcquiredAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAcquiredAt<St> {}
     impl<St: State> State for SetAcquiredAt<St> {
+        type AcquiredAt = Set<members::acquired_at>;
         type Quantity = St::Quantity;
+        type ItemId = St::ItemId;
         type CreatedAt = St::CreatedAt;
-        type AcquiredAt = Set<members::acquired_at>;
+    }
+    ///State transition - sets the `quantity` field to Set
+    pub struct SetQuantity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuantity<St> {}
+    impl<St: State> State for SetQuantity<St> {
+        type AcquiredAt = St::AcquiredAt;
+        type Quantity = Set<members::quantity>;
         type ItemId = St::ItemId;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `item_id` field to Set
     pub struct SetItemId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetItemId<St> {}
     impl<St: State> State for SetItemId<St> {
+        type AcquiredAt = St::AcquiredAt;
         type Quantity = St::Quantity;
+        type ItemId = Set<members::item_id>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type AcquiredAt = St::AcquiredAt;
-        type ItemId = Set<members::item_id>;
+        type Quantity = St::Quantity;
+        type ItemId = St::ItemId;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `quantity` field
-        pub struct quantity(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `acquired_at` field
         pub struct acquired_at(());
+        ///Marker type for the `quantity` field
+        pub struct quantity(());
         ///Marker type for the `item_id` field
         pub struct item_id(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -592,10 +592,10 @@ impl<S: BosStr, St: inventory_state::State> InventoryBuilder<S, St> {
 impl<S: BosStr, St> InventoryBuilder<S, St>
 where
     St: inventory_state::State,
-    St::Quantity: inventory_state::IsSet,
-    St::CreatedAt: inventory_state::IsSet,
     St::AcquiredAt: inventory_state::IsSet,
+    St::Quantity: inventory_state::IsSet,
     St::ItemId: inventory_state::IsSet,
+    St::CreatedAt: inventory_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Inventory<S> {
diff --git a/crates/jacquard-api/src/net_anisota/beta/game/pack.rs b/crates/jacquard-api/src/net_anisota/beta/game/pack.rs
index 4b20c64d..b0cb7183 100644
--- a/crates/jacquard-api/src/net_anisota/beta/game/pack.rs
+++ b/crates/jacquard-api/src/net_anisota/beta/game/pack.rs
@@ -233,65 +233,65 @@ pub mod pack_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TotalOpens;
         type Streak;
         type LastOpenTime;
+        type TotalOpens;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TotalOpens = Unset;
         type Streak = Unset;
         type LastOpenTime = Unset;
+        type TotalOpens = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `total_opens` field to Set
-    pub struct SetTotalOpens<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalOpens<St> {}
-    impl<St: State> State for SetTotalOpens<St> {
-        type TotalOpens = Set<members::total_opens>;
-        type Streak = St::Streak;
-        type LastOpenTime = St::LastOpenTime;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `streak` field to Set
     pub struct SetStreak<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStreak<St> {}
     impl<St: State> State for SetStreak<St> {
-        type TotalOpens = St::TotalOpens;
         type Streak = Set<members::streak>;
         type LastOpenTime = St::LastOpenTime;
+        type TotalOpens = St::TotalOpens;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `last_open_time` field to Set
     pub struct SetLastOpenTime<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLastOpenTime<St> {}
     impl<St: State> State for SetLastOpenTime<St> {
-        type TotalOpens = St::TotalOpens;
         type Streak = St::Streak;
         type LastOpenTime = Set<members::last_open_time>;
+        type TotalOpens = St::TotalOpens;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `total_opens` field to Set
+    pub struct SetTotalOpens<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalOpens<St> {}
+    impl<St: State> State for SetTotalOpens<St> {
+        type Streak = St::Streak;
+        type LastOpenTime = St::LastOpenTime;
+        type TotalOpens = Set<members::total_opens>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type TotalOpens = St::TotalOpens;
         type Streak = St::Streak;
         type LastOpenTime = St::LastOpenTime;
+        type TotalOpens = St::TotalOpens;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `total_opens` field
-        pub struct total_opens(());
         ///Marker type for the `streak` field
         pub struct streak(());
         ///Marker type for the `last_open_time` field
         pub struct last_open_time(());
+        ///Marker type for the `total_opens` field
+        pub struct total_opens(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -454,9 +454,9 @@ where
 impl<S: BosStr, St> PackBuilder<S, St>
 where
     St: pack_state::State,
-    St::TotalOpens: pack_state::IsSet,
     St::Streak: pack_state::IsSet,
     St::LastOpenTime: pack_state::IsSet,
+    St::TotalOpens: pack_state::IsSet,
     St::CreatedAt: pack_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_anisota/beta/game/progress.rs b/crates/jacquard-api/src/net_anisota/beta/game/progress.rs
index 95dd50bc..e8883e48 100644
--- a/crates/jacquard-api/src/net_anisota/beta/game/progress.rs
+++ b/crates/jacquard-api/src/net_anisota/beta/game/progress.rs
@@ -338,83 +338,83 @@ pub mod progress_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type XpToNextLevel;
+        type ProgressPercentage;
         type CreatedAt;
         type Level;
-        type ProgressPercentage;
-        type XpToNextLevel;
         type TotalXp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type XpToNextLevel = Unset;
+        type ProgressPercentage = Unset;
         type CreatedAt = Unset;
         type Level = Unset;
-        type ProgressPercentage = Unset;
-        type XpToNextLevel = Unset;
         type TotalXp = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Level = St::Level;
+    ///State transition - sets the `xp_to_next_level` field to Set
+    pub struct SetXpToNextLevel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetXpToNextLevel<St> {}
+    impl<St: State> State for SetXpToNextLevel<St> {
+        type XpToNextLevel = Set<members::xp_to_next_level>;
         type ProgressPercentage = St::ProgressPercentage;
-        type XpToNextLevel = St::XpToNextLevel;
-        type TotalXp = St::TotalXp;
-    }
-    ///State transition - sets the `level` field to Set
-    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLevel<St> {}
-    impl<St: State> State for SetLevel<St> {
         type CreatedAt = St::CreatedAt;
-        type Level = Set<members::level>;
-        type ProgressPercentage = St::ProgressPercentage;
-        type XpToNextLevel = St::XpToNextLevel;
+        type Level = St::Level;
         type TotalXp = St::TotalXp;
     }
     ///State transition - sets the `progress_percentage` field to Set
     pub struct SetProgressPercentage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetProgressPercentage<St> {}
     impl<St: State> State for SetProgressPercentage<St> {
+        type XpToNextLevel = St::XpToNextLevel;
+        type ProgressPercentage = Set<members::progress_percentage>;
         type CreatedAt = St::CreatedAt;
         type Level = St::Level;
-        type ProgressPercentage = Set<members::progress_percentage>;
-        type XpToNextLevel = St::XpToNextLevel;
         type TotalXp = St::TotalXp;
     }
-    ///State transition - sets the `xp_to_next_level` field to Set
-    pub struct SetXpToNextLevel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetXpToNextLevel<St> {}
-    impl<St: State> State for SetXpToNextLevel<St> {
-        type CreatedAt = St::CreatedAt;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type XpToNextLevel = St::XpToNextLevel;
+        type ProgressPercentage = St::ProgressPercentage;
+        type CreatedAt = Set<members::created_at>;
         type Level = St::Level;
+        type TotalXp = St::TotalXp;
+    }
+    ///State transition - sets the `level` field to Set
+    pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLevel<St> {}
+    impl<St: State> State for SetLevel<St> {
+        type XpToNextLevel = St::XpToNextLevel;
         type ProgressPercentage = St::ProgressPercentage;
-        type XpToNextLevel = Set<members::xp_to_next_level>;
+        type CreatedAt = St::CreatedAt;
+        type Level = Set<members::level>;
         type TotalXp = St::TotalXp;
     }
     ///State transition - sets the `total_xp` field to Set
     pub struct SetTotalXp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTotalXp<St> {}
     impl<St: State> State for SetTotalXp<St> {
+        type XpToNextLevel = St::XpToNextLevel;
+        type ProgressPercentage = St::ProgressPercentage;
         type CreatedAt = St::CreatedAt;
         type Level = St::Level;
-        type ProgressPercentage = St::ProgressPercentage;
-        type XpToNextLevel = St::XpToNextLevel;
         type TotalXp = Set<members::total_xp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `xp_to_next_level` field
+        pub struct xp_to_next_level(());
+        ///Marker type for the `progress_percentage` field
+        pub struct progress_percentage(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `level` field
         pub struct level(());
-        ///Marker type for the `progress_percentage` field
-        pub struct progress_percentage(());
-        ///Marker type for the `xp_to_next_level` field
-        pub struct xp_to_next_level(());
         ///Marker type for the `total_xp` field
         pub struct total_xp(());
     }
@@ -705,10 +705,10 @@ where
 impl<S: BosStr, St> ProgressBuilder<S, St>
 where
     St: progress_state::State,
+    St::XpToNextLevel: progress_state::IsSet,
+    St::ProgressPercentage: progress_state::IsSet,
     St::CreatedAt: progress_state::IsSet,
     St::Level: progress_state::IsSet,
-    St::ProgressPercentage: progress_state::IsSet,
-    St::XpToNextLevel: progress_state::IsSet,
     St::TotalXp: progress_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_anisota/beta/game/session.rs b/crates/jacquard-api/src/net_anisota/beta/game/session.rs
index 763a0f00..5fddd2c0 100644
--- a/crates/jacquard-api/src/net_anisota/beta/game/session.rs
+++ b/crates/jacquard-api/src/net_anisota/beta/game/session.rs
@@ -894,67 +894,67 @@ pub mod session_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Platform;
-        type StartedAt;
         type ClientVersion;
+        type Platform;
         type Status;
+        type StartedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Platform = Unset;
-        type StartedAt = Unset;
         type ClientVersion = Unset;
+        type Platform = Unset;
         type Status = Unset;
-    }
-    ///State transition - sets the `platform` field to Set
-    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlatform<St> {}
-    impl<St: State> State for SetPlatform<St> {
-        type Platform = Set<members::platform>;
-        type StartedAt = St::StartedAt;
-        type ClientVersion = St::ClientVersion;
-        type Status = St::Status;
-    }
-    ///State transition - sets the `started_at` field to Set
-    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
-    impl<St: State> State for SetStartedAt<St> {
-        type Platform = St::Platform;
-        type StartedAt = Set<members::started_at>;
-        type ClientVersion = St::ClientVersion;
-        type Status = St::Status;
+        type StartedAt = Unset;
     }
     ///State transition - sets the `client_version` field to Set
     pub struct SetClientVersion<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClientVersion<St> {}
     impl<St: State> State for SetClientVersion<St> {
+        type ClientVersion = Set<members::client_version>;
         type Platform = St::Platform;
+        type Status = St::Status;
         type StartedAt = St::StartedAt;
-        type ClientVersion = Set<members::client_version>;
+    }
+    ///State transition - sets the `platform` field to Set
+    pub struct SetPlatform<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlatform<St> {}
+    impl<St: State> State for SetPlatform<St> {
+        type ClientVersion = St::ClientVersion;
+        type Platform = Set<members::platform>;
         type Status = St::Status;
+        type StartedAt = St::StartedAt;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
+        type ClientVersion = St::ClientVersion;
         type Platform = St::Platform;
+        type Status = Set<members::status>;
         type StartedAt = St::StartedAt;
+    }
+    ///State transition - sets the `started_at` field to Set
+    pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartedAt<St> {}
+    impl<St: State> State for SetStartedAt<St> {
         type ClientVersion = St::ClientVersion;
-        type Status = Set<members::status>;
+        type Platform = St::Platform;
+        type Status = St::Status;
+        type StartedAt = Set<members::started_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `platform` field
-        pub struct platform(());
-        ///Marker type for the `started_at` field
-        pub struct started_at(());
         ///Marker type for the `client_version` field
         pub struct client_version(());
+        ///Marker type for the `platform` field
+        pub struct platform(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `started_at` field
+        pub struct started_at(());
     }
 }
 
@@ -1279,10 +1279,10 @@ impl<S: BosStr, St: session_state::State> SessionBuilder<S, St> {
 impl<S: BosStr, St> SessionBuilder<S, St>
 where
     St: session_state::State,
-    St::Platform: session_state::IsSet,
-    St::StartedAt: session_state::IsSet,
     St::ClientVersion: session_state::IsSet,
+    St::Platform: session_state::IsSet,
     St::Status: session_state::IsSet,
+    St::StartedAt: session_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Session<S> {
diff --git a/crates/jacquard-api/src/net_anisota/feed/draft.rs b/crates/jacquard-api/src/net_anisota/feed/draft.rs
index 44022afb..50fe4f2b 100644
--- a/crates/jacquard-api/src/net_anisota/feed/draft.rs
+++ b/crates/jacquard-api/src/net_anisota/feed/draft.rs
@@ -228,37 +228,37 @@ pub mod draft_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Text;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Text = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Text = St::Text;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
-        type CreatedAt = St::CreatedAt;
         type Text = Set<members::text>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Text = St::Text;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `text` field
         pub struct text(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -429,8 +429,8 @@ impl<S: BosStr, St: draft_state::State> DraftBuilder<S, St> {
 impl<S: BosStr, St> DraftBuilder<S, St>
 where
     St: draft_state::State,
-    St::CreatedAt: draft_state::IsSet,
     St::Text: draft_state::IsSet,
+    St::CreatedAt: draft_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Draft<S> {
@@ -663,37 +663,37 @@ pub mod reply_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Parent;
         type Root;
+        type Parent;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Parent = Unset;
         type Root = Unset;
-    }
-    ///State transition - sets the `parent` field to Set
-    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetParent<St> {}
-    impl<St: State> State for SetParent<St> {
-        type Parent = Set<members::parent>;
-        type Root = St::Root;
+        type Parent = Unset;
     }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
-        type Parent = St::Parent;
         type Root = Set<members::root>;
+        type Parent = St::Parent;
+    }
+    ///State transition - sets the `parent` field to Set
+    pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetParent<St> {}
+    impl<St: State> State for SetParent<St> {
+        type Root = St::Root;
+        type Parent = Set<members::parent>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `parent` field
-        pub struct parent(());
         ///Marker type for the `root` field
         pub struct root(());
+        ///Marker type for the `parent` field
+        pub struct parent(());
     }
 }
 
@@ -763,8 +763,8 @@ where
 impl<S: BosStr, St> ReplyRefBuilder<S, St>
 where
     St: reply_ref_state::State,
-    St::Parent: reply_ref_state::IsSet,
     St::Root: reply_ref_state::IsSet,
+    St::Parent: reply_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReplyRef<S> {
diff --git a/crates/jacquard-api/src/net_anisota/feed/list.rs b/crates/jacquard-api/src/net_anisota/feed/list.rs
index b190b1a8..cfaf20e9 100644
--- a/crates/jacquard-api/src/net_anisota/feed/list.rs
+++ b/crates/jacquard-api/src/net_anisota/feed/list.rs
@@ -195,37 +195,37 @@ pub mod list_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -340,8 +340,8 @@ impl<S: BosStr, St: list_state::State> ListBuilder<S, St> {
 impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
-    St::Name: list_state::IsSet,
     St::CreatedAt: list_state::IsSet,
+    St::Name: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/net_anisota/feed/list_item.rs b/crates/jacquard-api/src/net_anisota/feed/list_item.rs
index 2982301c..47d22fd9 100644
--- a/crates/jacquard-api/src/net_anisota/feed/list_item.rs
+++ b/crates/jacquard-api/src/net_anisota/feed/list_item.rs
@@ -117,50 +117,50 @@ pub mod list_item_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Subject;
-        type CreatedAt;
         type List;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Subject = Unset;
-        type CreatedAt = Unset;
         type List = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
         type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
-        type List = St::List;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
         type List = St::List;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `list` field to Set
     pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetList<St> {}
     impl<St: State> State for SetList<St> {
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
         type List = Set<members::list>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type List = St::List;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `list` field
         pub struct list(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -250,8 +250,8 @@ impl<S: BosStr, St> ListItemBuilder<S, St>
 where
     St: list_item_state::State,
     St::Subject: list_item_state::IsSet,
-    St::CreatedAt: list_item_state::IsSet,
     St::List: list_item_state::IsSet,
+    St::CreatedAt: list_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListItem<S> {
diff --git a/crates/jacquard-api/src/net_anisota/feed/post.rs b/crates/jacquard-api/src/net_anisota/feed/post.rs
index a1380308..5f3470ec 100644
--- a/crates/jacquard-api/src/net_anisota/feed/post.rs
+++ b/crates/jacquard-api/src/net_anisota/feed/post.rs
@@ -632,37 +632,37 @@ pub mod reply_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Root;
         type Parent;
+        type Root;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Root = Unset;
         type Parent = Unset;
-    }
-    ///State transition - sets the `root` field to Set
-    pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRoot<St> {}
-    impl<St: State> State for SetRoot<St> {
-        type Root = Set<members::root>;
-        type Parent = St::Parent;
+        type Root = Unset;
     }
     ///State transition - sets the `parent` field to Set
     pub struct SetParent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParent<St> {}
     impl<St: State> State for SetParent<St> {
-        type Root = St::Root;
         type Parent = Set<members::parent>;
+        type Root = St::Root;
+    }
+    ///State transition - sets the `root` field to Set
+    pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRoot<St> {}
+    impl<St: State> State for SetRoot<St> {
+        type Parent = St::Parent;
+        type Root = Set<members::root>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `root` field
-        pub struct root(());
         ///Marker type for the `parent` field
         pub struct parent(());
+        ///Marker type for the `root` field
+        pub struct root(());
     }
 }
 
@@ -732,8 +732,8 @@ where
 impl<S: BosStr, St> ReplyRefBuilder<S, St>
 where
     St: reply_ref_state::State,
-    St::Root: reply_ref_state::IsSet,
     St::Parent: reply_ref_state::IsSet,
+    St::Root: reply_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReplyRef<S> {
diff --git a/crates/jacquard-api/src/net_anisota/feed/repost.rs b/crates/jacquard-api/src/net_anisota/feed/repost.rs
index a30db08e..b0f1c5a7 100644
--- a/crates/jacquard-api/src/net_anisota/feed/repost.rs
+++ b/crates/jacquard-api/src/net_anisota/feed/repost.rs
@@ -115,37 +115,37 @@ pub mod repost_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -215,8 +215,8 @@ where
 impl<S: BosStr, St> RepostBuilder<S, St>
 where
     St: repost_state::State,
-    St::CreatedAt: repost_state::IsSet,
     St::Subject: repost_state::IsSet,
+    St::CreatedAt: repost_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Repost<S> {
diff --git a/crates/jacquard-api/src/net_anisota/graph/mute.rs b/crates/jacquard-api/src/net_anisota/graph/mute.rs
index 27f4eac8..c962886d 100644
--- a/crates/jacquard-api/src/net_anisota/graph/mute.rs
+++ b/crates/jacquard-api/src/net_anisota/graph/mute.rs
@@ -364,37 +364,37 @@ pub mod mute_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -526,8 +526,8 @@ impl<S: BosStr, St: mute_state::State> MuteBuilder<S, St> {
 impl<S: BosStr, St> MuteBuilder<S, St>
 where
     St: mute_state::State,
-    St::CreatedAt: mute_state::IsSet,
     St::Subject: mute_state::IsSet,
+    St::CreatedAt: mute_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Mute<S> {
diff --git a/crates/jacquard-api/src/net_anisota/harvest/minigame.rs b/crates/jacquard-api/src/net_anisota/harvest/minigame.rs
index aba7cbb8..3dc4243d 100644
--- a/crates/jacquard-api/src/net_anisota/harvest/minigame.rs
+++ b/crates/jacquard-api/src/net_anisota/harvest/minigame.rs
@@ -360,85 +360,85 @@ pub mod minigame_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type RoundDuration;
         type PlayedAt;
-        type FinalScore;
         type ShapesCollected;
+        type RoundDuration;
         type GameContext;
+        type FinalScore;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type RoundDuration = Unset;
         type PlayedAt = Unset;
-        type FinalScore = Unset;
         type ShapesCollected = Unset;
+        type RoundDuration = Unset;
         type GameContext = Unset;
-    }
-    ///State transition - sets the `round_duration` field to Set
-    pub struct SetRoundDuration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRoundDuration<St> {}
-    impl<St: State> State for SetRoundDuration<St> {
-        type RoundDuration = Set<members::round_duration>;
-        type PlayedAt = St::PlayedAt;
-        type FinalScore = St::FinalScore;
-        type ShapesCollected = St::ShapesCollected;
-        type GameContext = St::GameContext;
+        type FinalScore = Unset;
     }
     ///State transition - sets the `played_at` field to Set
     pub struct SetPlayedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlayedAt<St> {}
     impl<St: State> State for SetPlayedAt<St> {
-        type RoundDuration = St::RoundDuration;
         type PlayedAt = Set<members::played_at>;
-        type FinalScore = St::FinalScore;
         type ShapesCollected = St::ShapesCollected;
-        type GameContext = St::GameContext;
-    }
-    ///State transition - sets the `final_score` field to Set
-    pub struct SetFinalScore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFinalScore<St> {}
-    impl<St: State> State for SetFinalScore<St> {
         type RoundDuration = St::RoundDuration;
-        type PlayedAt = St::PlayedAt;
-        type FinalScore = Set<members::final_score>;
-        type ShapesCollected = St::ShapesCollected;
         type GameContext = St::GameContext;
+        type FinalScore = St::FinalScore;
     }
     ///State transition - sets the `shapes_collected` field to Set
     pub struct SetShapesCollected<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetShapesCollected<St> {}
     impl<St: State> State for SetShapesCollected<St> {
-        type RoundDuration = St::RoundDuration;
         type PlayedAt = St::PlayedAt;
-        type FinalScore = St::FinalScore;
         type ShapesCollected = Set<members::shapes_collected>;
+        type RoundDuration = St::RoundDuration;
+        type GameContext = St::GameContext;
+        type FinalScore = St::FinalScore;
+    }
+    ///State transition - sets the `round_duration` field to Set
+    pub struct SetRoundDuration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRoundDuration<St> {}
+    impl<St: State> State for SetRoundDuration<St> {
+        type PlayedAt = St::PlayedAt;
+        type ShapesCollected = St::ShapesCollected;
+        type RoundDuration = Set<members::round_duration>;
         type GameContext = St::GameContext;
+        type FinalScore = St::FinalScore;
     }
     ///State transition - sets the `game_context` field to Set
     pub struct SetGameContext<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGameContext<St> {}
     impl<St: State> State for SetGameContext<St> {
-        type RoundDuration = St::RoundDuration;
         type PlayedAt = St::PlayedAt;
-        type FinalScore = St::FinalScore;
         type ShapesCollected = St::ShapesCollected;
+        type RoundDuration = St::RoundDuration;
         type GameContext = Set<members::game_context>;
+        type FinalScore = St::FinalScore;
+    }
+    ///State transition - sets the `final_score` field to Set
+    pub struct SetFinalScore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFinalScore<St> {}
+    impl<St: State> State for SetFinalScore<St> {
+        type PlayedAt = St::PlayedAt;
+        type ShapesCollected = St::ShapesCollected;
+        type RoundDuration = St::RoundDuration;
+        type GameContext = St::GameContext;
+        type FinalScore = Set<members::final_score>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `round_duration` field
-        pub struct round_duration(());
         ///Marker type for the `played_at` field
         pub struct played_at(());
-        ///Marker type for the `final_score` field
-        pub struct final_score(());
         ///Marker type for the `shapes_collected` field
         pub struct shapes_collected(());
+        ///Marker type for the `round_duration` field
+        pub struct round_duration(());
         ///Marker type for the `game_context` field
         pub struct game_context(());
+        ///Marker type for the `final_score` field
+        pub struct final_score(());
     }
 }
 
@@ -763,11 +763,11 @@ impl<S: BosStr, St: minigame_state::State> MinigameBuilder<S, St> {
 impl<S: BosStr, St> MinigameBuilder<S, St>
 where
     St: minigame_state::State,
-    St::RoundDuration: minigame_state::IsSet,
     St::PlayedAt: minigame_state::IsSet,
-    St::FinalScore: minigame_state::IsSet,
     St::ShapesCollected: minigame_state::IsSet,
+    St::RoundDuration: minigame_state::IsSet,
     St::GameContext: minigame_state::IsSet,
+    St::FinalScore: minigame_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Minigame<S> {
diff --git a/crates/jacquard-api/src/net_anisota/settings.rs b/crates/jacquard-api/src/net_anisota/settings.rs
index 78c66f91..3740183e 100644
--- a/crates/jacquard-api/src/net_anisota/settings.rs
+++ b/crates/jacquard-api/src/net_anisota/settings.rs
@@ -3115,50 +3115,50 @@ pub mod settings_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type UpdatedAt;
-        type Version;
         type CreatedAt;
+        type Version;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type UpdatedAt = Unset;
-        type Version = Unset;
         type CreatedAt = Unset;
+        type Version = Unset;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
         type UpdatedAt = Set<members::updated_at>;
-        type Version = St::Version;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `version` field to Set
-    pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVersion<St> {}
-    impl<St: State> State for SetVersion<St> {
-        type UpdatedAt = St::UpdatedAt;
-        type Version = Set<members::version>;
         type CreatedAt = St::CreatedAt;
+        type Version = St::Version;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type UpdatedAt = St::UpdatedAt;
-        type Version = St::Version;
         type CreatedAt = Set<members::created_at>;
+        type Version = St::Version;
+    }
+    ///State transition - sets the `version` field to Set
+    pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVersion<St> {}
+    impl<St: State> State for SetVersion<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = St::CreatedAt;
+        type Version = Set<members::version>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
-        ///Marker type for the `version` field
-        pub struct version(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `version` field
+        pub struct version(());
     }
 }
 
@@ -3337,8 +3337,8 @@ impl<S: BosStr, St> SettingsBuilder<S, St>
 where
     St: settings_state::State,
     St::UpdatedAt: settings_state::IsSet,
-    St::Version: settings_state::IsSet,
     St::CreatedAt: settings_state::IsSet,
+    St::Version: settings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Settings<S> {
diff --git a/crates/jacquard-api/src/net_asadaame5121/at_circle/banner.rs b/crates/jacquard-api/src/net_asadaame5121/at_circle/banner.rs
index 11356136..b72a9516 100644
--- a/crates/jacquard-api/src/net_asadaame5121/at_circle/banner.rs
+++ b/crates/jacquard-api/src/net_asadaame5121/at_circle/banner.rs
@@ -155,51 +155,51 @@ pub mod banner_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Banner;
         type Ring;
+        type Banner;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Banner = Unset;
         type Ring = Unset;
+        type Banner = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `ring` field to Set
+    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRing<St> {}
+    impl<St: State> State for SetRing<St> {
+        type Ring = Set<members::ring>;
         type Banner = St::Banner;
-        type Ring = St::Ring;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `banner` field to Set
     pub struct SetBanner<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBanner<St> {}
     impl<St: State> State for SetBanner<St> {
-        type CreatedAt = St::CreatedAt;
-        type Banner = Set<members::banner>;
         type Ring = St::Ring;
-    }
-    ///State transition - sets the `ring` field to Set
-    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRing<St> {}
-    impl<St: State> State for SetRing<St> {
+        type Banner = Set<members::banner>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Ring = St::Ring;
         type Banner = St::Banner;
-        type Ring = Set<members::ring>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `banner` field
-        pub struct banner(());
         ///Marker type for the `ring` field
         pub struct ring(());
+        ///Marker type for the `banner` field
+        pub struct banner(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -288,9 +288,9 @@ where
 impl<S: BosStr, St> BannerBuilder<S, St>
 where
     St: banner_state::State,
-    St::CreatedAt: banner_state::IsSet,
-    St::Banner: banner_state::IsSet,
     St::Ring: banner_state::IsSet,
+    St::Banner: banner_state::IsSet,
+    St::CreatedAt: banner_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Banner<S> {
diff --git a/crates/jacquard-api/src/net_asadaame5121/at_circle/block.rs b/crates/jacquard-api/src/net_asadaame5121/at_circle/block.rs
index f15c815b..dc92dfae 100644
--- a/crates/jacquard-api/src/net_asadaame5121/at_circle/block.rs
+++ b/crates/jacquard-api/src/net_asadaame5121/at_circle/block.rs
@@ -151,51 +151,51 @@ pub mod block_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Subject;
         type Ring;
+        type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Subject = Unset;
         type Ring = Unset;
+        type Subject = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `ring` field to Set
+    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRing<St> {}
+    impl<St: State> State for SetRing<St> {
+        type Ring = Set<members::ring>;
         type Subject = St::Subject;
-        type Ring = St::Ring;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
         type Ring = St::Ring;
-    }
-    ///State transition - sets the `ring` field to Set
-    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRing<St> {}
-    impl<St: State> State for SetRing<St> {
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Ring = St::Ring;
         type Subject = St::Subject;
-        type Ring = Set<members::ring>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `ring` field
         pub struct ring(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -297,9 +297,9 @@ where
 impl<S: BosStr, St> BlockBuilder<S, St>
 where
     St: block_state::State,
-    St::CreatedAt: block_state::IsSet,
-    St::Subject: block_state::IsSet,
     St::Ring: block_state::IsSet,
+    St::Subject: block_state::IsSet,
+    St::CreatedAt: block_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Block<S> {
diff --git a/crates/jacquard-api/src/net_asadaame5121/at_circle/member.rs b/crates/jacquard-api/src/net_asadaame5121/at_circle/member.rs
index 23186fc8..7666a593 100644
--- a/crates/jacquard-api/src/net_asadaame5121/at_circle/member.rs
+++ b/crates/jacquard-api/src/net_asadaame5121/at_circle/member.rs
@@ -190,65 +190,65 @@ pub mod member_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Ring;
         type Url;
         type Title;
-        type Ring;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Ring = Unset;
         type Url = Unset;
         type Title = Unset;
-        type Ring = Unset;
         type CreatedAt = Unset;
     }
+    ///State transition - sets the `ring` field to Set
+    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRing<St> {}
+    impl<St: State> State for SetRing<St> {
+        type Ring = Set<members::ring>;
+        type Url = St::Url;
+        type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
+    }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
+        type Ring = St::Ring;
         type Url = Set<members::url>;
         type Title = St::Title;
-        type Ring = St::Ring;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Url = St::Url;
-        type Title = Set<members::title>;
         type Ring = St::Ring;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `ring` field to Set
-    pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRing<St> {}
-    impl<St: State> State for SetRing<St> {
         type Url = St::Url;
-        type Title = St::Title;
-        type Ring = Set<members::ring>;
+        type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Ring = St::Ring;
         type Url = St::Url;
         type Title = St::Title;
-        type Ring = St::Ring;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `ring` field
+        pub struct ring(());
         ///Marker type for the `url` field
         pub struct url(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `ring` field
-        pub struct ring(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -391,9 +391,9 @@ where
 impl<S: BosStr, St> MemberBuilder<S, St>
 where
     St: member_state::State,
+    St::Ring: member_state::IsSet,
     St::Url: member_state::IsSet,
     St::Title: member_state::IsSet,
-    St::Ring: member_state::IsSet,
     St::CreatedAt: member_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/net_asadaame5121/at_circle/request.rs b/crates/jacquard-api/src/net_asadaame5121/at_circle/request.rs
index 8bf25ead..31c860e3 100644
--- a/crates/jacquard-api/src/net_asadaame5121/at_circle/request.rs
+++ b/crates/jacquard-api/src/net_asadaame5121/at_circle/request.rs
@@ -171,8 +171,8 @@ pub mod request_state {
     pub trait State: sealed::Sealed {
         type Ring;
         type SiteTitle;
-        type CreatedAt;
         type SiteUrl;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -180,8 +180,8 @@ pub mod request_state {
     impl State for Empty {
         type Ring = Unset;
         type SiteTitle = Unset;
-        type CreatedAt = Unset;
         type SiteUrl = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `ring` field to Set
     pub struct SetRing<St: State = Empty>(PhantomData<fn() -> St>);
@@ -189,8 +189,8 @@ pub mod request_state {
     impl<St: State> State for SetRing<St> {
         type Ring = Set<members::ring>;
         type SiteTitle = St::SiteTitle;
-        type CreatedAt = St::CreatedAt;
         type SiteUrl = St::SiteUrl;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `site_title` field to Set
     pub struct SetSiteTitle<St: State = Empty>(PhantomData<fn() -> St>);
@@ -198,17 +198,8 @@ pub mod request_state {
     impl<St: State> State for SetSiteTitle<St> {
         type Ring = St::Ring;
         type SiteTitle = Set<members::site_title>;
-        type CreatedAt = St::CreatedAt;
-        type SiteUrl = St::SiteUrl;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Ring = St::Ring;
-        type SiteTitle = St::SiteTitle;
-        type CreatedAt = Set<members::created_at>;
         type SiteUrl = St::SiteUrl;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `site_url` field to Set
     pub struct SetSiteUrl<St: State = Empty>(PhantomData<fn() -> St>);
@@ -216,8 +207,17 @@ pub mod request_state {
     impl<St: State> State for SetSiteUrl<St> {
         type Ring = St::Ring;
         type SiteTitle = St::SiteTitle;
-        type CreatedAt = St::CreatedAt;
         type SiteUrl = Set<members::site_url>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Ring = St::Ring;
+        type SiteTitle = St::SiteTitle;
+        type SiteUrl = St::SiteUrl;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -226,10 +226,10 @@ pub mod request_state {
         pub struct ring(());
         ///Marker type for the `site_title` field
         pub struct site_title(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `site_url` field
         pub struct site_url(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -372,8 +372,8 @@ where
     St: request_state::State,
     St::Ring: request_state::IsSet,
     St::SiteTitle: request_state::IsSet,
-    St::CreatedAt: request_state::IsSet,
     St::SiteUrl: request_state::IsSet,
+    St::CreatedAt: request_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Request<S> {
diff --git a/crates/jacquard-api/src/net_jbsm/jb/reminder.rs b/crates/jacquard-api/src/net_jbsm/jb/reminder.rs
index 454f3dce..07121053 100644
--- a/crates/jacquard-api/src/net_jbsm/jb/reminder.rs
+++ b/crates/jacquard-api/src/net_jbsm/jb/reminder.rs
@@ -140,67 +140,67 @@ pub mod reminder_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TriggerAt;
         type Subject;
-        type Requester;
         type CreatedAt;
+        type TriggerAt;
+        type Requester;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TriggerAt = Unset;
         type Subject = Unset;
-        type Requester = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `trigger_at` field to Set
-    pub struct SetTriggerAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTriggerAt<St> {}
-    impl<St: State> State for SetTriggerAt<St> {
-        type TriggerAt = Set<members::trigger_at>;
-        type Subject = St::Subject;
-        type Requester = St::Requester;
-        type CreatedAt = St::CreatedAt;
+        type TriggerAt = Unset;
+        type Requester = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type TriggerAt = St::TriggerAt;
         type Subject = Set<members::subject>;
-        type Requester = St::Requester;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `requester` field to Set
-    pub struct SetRequester<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRequester<St> {}
-    impl<St: State> State for SetRequester<St> {
         type TriggerAt = St::TriggerAt;
-        type Subject = St::Subject;
-        type Requester = Set<members::requester>;
-        type CreatedAt = St::CreatedAt;
+        type Requester = St::Requester;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
         type TriggerAt = St::TriggerAt;
+        type Requester = St::Requester;
+    }
+    ///State transition - sets the `trigger_at` field to Set
+    pub struct SetTriggerAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTriggerAt<St> {}
+    impl<St: State> State for SetTriggerAt<St> {
         type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+        type TriggerAt = Set<members::trigger_at>;
         type Requester = St::Requester;
-        type CreatedAt = Set<members::created_at>;
+    }
+    ///State transition - sets the `requester` field to Set
+    pub struct SetRequester<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRequester<St> {}
+    impl<St: State> State for SetRequester<St> {
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
+        type TriggerAt = St::TriggerAt;
+        type Requester = Set<members::requester>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `trigger_at` field
-        pub struct trigger_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `requester` field
-        pub struct requester(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `trigger_at` field
+        pub struct trigger_at(());
+        ///Marker type for the `requester` field
+        pub struct requester(());
     }
 }
 
@@ -341,10 +341,10 @@ where
 impl<S: BosStr, St> ReminderBuilder<S, St>
 where
     St: reminder_state::State,
-    St::TriggerAt: reminder_state::IsSet,
     St::Subject: reminder_state::IsSet,
-    St::Requester: reminder_state::IsSet,
     St::CreatedAt: reminder_state::IsSet,
+    St::TriggerAt: reminder_state::IsSet,
+    St::Requester: reminder_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reminder<S> {
diff --git a/crates/jacquard-api/src/net_mmatt/vitals/car.rs b/crates/jacquard-api/src/net_mmatt/vitals/car.rs
index c64e0529..76d0b399 100644
--- a/crates/jacquard-api/src/net_mmatt/vitals/car.rs
+++ b/crates/jacquard-api/src/net_mmatt/vitals/car.rs
@@ -128,77 +128,75 @@ pub mod car_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type CarTraveledDistance;
         type CarFuelRange;
         type CarPercentFuelRemaining;
         type AmountRemaining;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type CarTraveledDistance = Unset;
         type CarFuelRange = Unset;
         type CarPercentFuelRemaining = Unset;
         type AmountRemaining = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type CarTraveledDistance = St::CarTraveledDistance;
-        type CarFuelRange = St::CarFuelRange;
-        type CarPercentFuelRemaining = St::CarPercentFuelRemaining;
-        type AmountRemaining = St::AmountRemaining;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `car_traveled_distance` field to Set
     pub struct SetCarTraveledDistance<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCarTraveledDistance<St> {}
     impl<St: State> State for SetCarTraveledDistance<St> {
-        type CreatedAt = St::CreatedAt;
         type CarTraveledDistance = Set<members::car_traveled_distance>;
         type CarFuelRange = St::CarFuelRange;
         type CarPercentFuelRemaining = St::CarPercentFuelRemaining;
         type AmountRemaining = St::AmountRemaining;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `car_fuel_range` field to Set
     pub struct SetCarFuelRange<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCarFuelRange<St> {}
     impl<St: State> State for SetCarFuelRange<St> {
-        type CreatedAt = St::CreatedAt;
         type CarTraveledDistance = St::CarTraveledDistance;
         type CarFuelRange = Set<members::car_fuel_range>;
         type CarPercentFuelRemaining = St::CarPercentFuelRemaining;
         type AmountRemaining = St::AmountRemaining;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `car_percent_fuel_remaining` field to Set
     pub struct SetCarPercentFuelRemaining<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCarPercentFuelRemaining<St> {}
     impl<St: State> State for SetCarPercentFuelRemaining<St> {
-        type CreatedAt = St::CreatedAt;
         type CarTraveledDistance = St::CarTraveledDistance;
         type CarFuelRange = St::CarFuelRange;
         type CarPercentFuelRemaining = Set<members::car_percent_fuel_remaining>;
         type AmountRemaining = St::AmountRemaining;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `amount_remaining` field to Set
     pub struct SetAmountRemaining<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAmountRemaining<St> {}
     impl<St: State> State for SetAmountRemaining<St> {
-        type CreatedAt = St::CreatedAt;
         type CarTraveledDistance = St::CarTraveledDistance;
         type CarFuelRange = St::CarFuelRange;
         type CarPercentFuelRemaining = St::CarPercentFuelRemaining;
         type AmountRemaining = Set<members::amount_remaining>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CarTraveledDistance = St::CarTraveledDistance;
+        type CarFuelRange = St::CarFuelRange;
+        type CarPercentFuelRemaining = St::CarPercentFuelRemaining;
+        type AmountRemaining = St::AmountRemaining;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `car_traveled_distance` field
         pub struct car_traveled_distance(());
         ///Marker type for the `car_fuel_range` field
@@ -207,6 +205,8 @@ pub mod car_state {
         pub struct car_percent_fuel_remaining(());
         ///Marker type for the `amount_remaining` field
         pub struct amount_remaining(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -381,11 +381,11 @@ where
 impl<S: BosStr, St> CarBuilder<S, St>
 where
     St: car_state::State,
-    St::CreatedAt: car_state::IsSet,
     St::CarTraveledDistance: car_state::IsSet,
     St::CarFuelRange: car_state::IsSet,
     St::CarPercentFuelRemaining: car_state::IsSet,
     St::AmountRemaining: car_state::IsSet,
+    St::CreatedAt: car_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Car<S> {
diff --git a/crates/jacquard-api/src/network_cosmik/collection_link.rs b/crates/jacquard-api/src/network_cosmik/collection_link.rs
index 5b8da641..0815372a 100644
--- a/crates/jacquard-api/src/network_cosmik/collection_link.rs
+++ b/crates/jacquard-api/src/network_cosmik/collection_link.rs
@@ -129,67 +129,67 @@ pub mod collection_link_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Collection;
-        type AddedBy;
         type Card;
         type AddedAt;
+        type Collection;
+        type AddedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Collection = Unset;
-        type AddedBy = Unset;
         type Card = Unset;
         type AddedAt = Unset;
-    }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
-        type AddedBy = St::AddedBy;
-        type Card = St::Card;
-        type AddedAt = St::AddedAt;
-    }
-    ///State transition - sets the `added_by` field to Set
-    pub struct SetAddedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddedBy<St> {}
-    impl<St: State> State for SetAddedBy<St> {
-        type Collection = St::Collection;
-        type AddedBy = Set<members::added_by>;
-        type Card = St::Card;
-        type AddedAt = St::AddedAt;
+        type Collection = Unset;
+        type AddedBy = Unset;
     }
     ///State transition - sets the `card` field to Set
     pub struct SetCard<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCard<St> {}
     impl<St: State> State for SetCard<St> {
-        type Collection = St::Collection;
-        type AddedBy = St::AddedBy;
         type Card = Set<members::card>;
         type AddedAt = St::AddedAt;
+        type Collection = St::Collection;
+        type AddedBy = St::AddedBy;
     }
     ///State transition - sets the `added_at` field to Set
     pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAddedAt<St> {}
     impl<St: State> State for SetAddedAt<St> {
+        type Card = St::Card;
+        type AddedAt = Set<members::added_at>;
         type Collection = St::Collection;
         type AddedBy = St::AddedBy;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
         type Card = St::Card;
-        type AddedAt = Set<members::added_at>;
+        type AddedAt = St::AddedAt;
+        type Collection = Set<members::collection>;
+        type AddedBy = St::AddedBy;
+    }
+    ///State transition - sets the `added_by` field to Set
+    pub struct SetAddedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddedBy<St> {}
+    impl<St: State> State for SetAddedBy<St> {
+        type Card = St::Card;
+        type AddedAt = St::AddedAt;
+        type Collection = St::Collection;
+        type AddedBy = Set<members::added_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collection` field
-        pub struct collection(());
-        ///Marker type for the `added_by` field
-        pub struct added_by(());
         ///Marker type for the `card` field
         pub struct card(());
         ///Marker type for the `added_at` field
         pub struct added_at(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
+        ///Marker type for the `added_by` field
+        pub struct added_by(());
     }
 }
 
@@ -344,10 +344,10 @@ impl<S: BosStr, St: collection_link_state::State> CollectionLinkBuilder<S, St> {
 impl<S: BosStr, St> CollectionLinkBuilder<S, St>
 where
     St: collection_link_state::State,
-    St::Collection: collection_link_state::IsSet,
-    St::AddedBy: collection_link_state::IsSet,
     St::Card: collection_link_state::IsSet,
     St::AddedAt: collection_link_state::IsSet,
+    St::Collection: collection_link_state::IsSet,
+    St::AddedBy: collection_link_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionLink<S> {
diff --git a/crates/jacquard-api/src/network_cosmik/collection_link_removal.rs b/crates/jacquard-api/src/network_cosmik/collection_link_removal.rs
index ab6ef157..7f6805a1 100644
--- a/crates/jacquard-api/src/network_cosmik/collection_link_removal.rs
+++ b/crates/jacquard-api/src/network_cosmik/collection_link_removal.rs
@@ -118,51 +118,51 @@ pub mod collection_link_removal_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type RemovedAt;
-        type Collection;
         type RemovedLink;
+        type Collection;
+        type RemovedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type RemovedAt = Unset;
-        type Collection = Unset;
         type RemovedLink = Unset;
+        type Collection = Unset;
+        type RemovedAt = Unset;
     }
-    ///State transition - sets the `removed_at` field to Set
-    pub struct SetRemovedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRemovedAt<St> {}
-    impl<St: State> State for SetRemovedAt<St> {
-        type RemovedAt = Set<members::removed_at>;
+    ///State transition - sets the `removed_link` field to Set
+    pub struct SetRemovedLink<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRemovedLink<St> {}
+    impl<St: State> State for SetRemovedLink<St> {
+        type RemovedLink = Set<members::removed_link>;
         type Collection = St::Collection;
-        type RemovedLink = St::RemovedLink;
+        type RemovedAt = St::RemovedAt;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type RemovedAt = St::RemovedAt;
-        type Collection = Set<members::collection>;
         type RemovedLink = St::RemovedLink;
-    }
-    ///State transition - sets the `removed_link` field to Set
-    pub struct SetRemovedLink<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRemovedLink<St> {}
-    impl<St: State> State for SetRemovedLink<St> {
+        type Collection = Set<members::collection>;
         type RemovedAt = St::RemovedAt;
+    }
+    ///State transition - sets the `removed_at` field to Set
+    pub struct SetRemovedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRemovedAt<St> {}
+    impl<St: State> State for SetRemovedAt<St> {
+        type RemovedLink = St::RemovedLink;
         type Collection = St::Collection;
-        type RemovedLink = Set<members::removed_link>;
+        type RemovedAt = Set<members::removed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `removed_at` field
-        pub struct removed_at(());
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `removed_link` field
         pub struct removed_link(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
+        ///Marker type for the `removed_at` field
+        pub struct removed_at(());
     }
 }
 
@@ -266,9 +266,9 @@ where
 impl<S: BosStr, St> CollectionLinkRemovalBuilder<S, St>
 where
     St: collection_link_removal_state::State,
-    St::RemovedAt: collection_link_removal_state::IsSet,
-    St::Collection: collection_link_removal_state::IsSet,
     St::RemovedLink: collection_link_removal_state::IsSet,
+    St::Collection: collection_link_removal_state::IsSet,
+    St::RemovedAt: collection_link_removal_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionLinkRemoval<S> {
diff --git a/crates/jacquard-api/src/network_cosmik/connection.rs b/crates/jacquard-api/src/network_cosmik/connection.rs
index e5ca03ff..938d4878 100644
--- a/crates/jacquard-api/src/network_cosmik/connection.rs
+++ b/crates/jacquard-api/src/network_cosmik/connection.rs
@@ -136,37 +136,37 @@ pub mod connection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Source;
         type Target;
+        type Source;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Source = Unset;
         type Target = Unset;
-    }
-    ///State transition - sets the `source` field to Set
-    pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSource<St> {}
-    impl<St: State> State for SetSource<St> {
-        type Source = Set<members::source>;
-        type Target = St::Target;
+        type Source = Unset;
     }
     ///State transition - sets the `target` field to Set
     pub struct SetTarget<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTarget<St> {}
     impl<St: State> State for SetTarget<St> {
-        type Source = St::Source;
         type Target = Set<members::target>;
+        type Source = St::Source;
+    }
+    ///State transition - sets the `source` field to Set
+    pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSource<St> {}
+    impl<St: State> State for SetSource<St> {
+        type Target = St::Target;
+        type Source = Set<members::source>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `source` field
-        pub struct source(());
         ///Marker type for the `target` field
         pub struct target(());
+        ///Marker type for the `source` field
+        pub struct source(());
     }
 }
 
@@ -295,8 +295,8 @@ impl<S: BosStr, St: connection_state::State> ConnectionBuilder<S, St> {
 impl<S: BosStr, St> ConnectionBuilder<S, St>
 where
     St: connection_state::State,
-    St::Source: connection_state::IsSet,
     St::Target: connection_state::IsSet,
+    St::Source: connection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Connection<S> {
diff --git a/crates/jacquard-api/src/network_slices/actor.rs b/crates/jacquard-api/src/network_slices/actor.rs
index 3e584b0a..837292dc 100644
--- a/crates/jacquard-api/src/network_slices/actor.rs
+++ b/crates/jacquard-api/src/network_slices/actor.rs
@@ -113,37 +113,37 @@ pub mod profile_view_basic_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Handle;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Handle = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Handle = St::Handle;
+        type Did = Unset;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
         type Handle = Set<members::handle>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Handle = St::Handle;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -252,8 +252,8 @@ where
 impl<S: BosStr, St> ProfileViewBasicBuilder<S, St>
 where
     St: profile_view_basic_state::State,
-    St::Did: profile_view_basic_state::IsSet,
     St::Handle: profile_view_basic_state::IsSet,
+    St::Did: profile_view_basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileViewBasic<S> {
diff --git a/crates/jacquard-api/src/network_slices/lexicon.rs b/crates/jacquard-api/src/network_slices/lexicon.rs
index 9d14ab56..e7fb03a1 100644
--- a/crates/jacquard-api/src/network_slices/lexicon.rs
+++ b/crates/jacquard-api/src/network_slices/lexicon.rs
@@ -152,65 +152,65 @@ pub mod lexicon_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Nsid;
         type Definitions;
         type CreatedAt;
-        type Nsid;
         type Slice;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Nsid = Unset;
         type Definitions = Unset;
         type CreatedAt = Unset;
-        type Nsid = Unset;
         type Slice = Unset;
     }
+    ///State transition - sets the `nsid` field to Set
+    pub struct SetNsid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNsid<St> {}
+    impl<St: State> State for SetNsid<St> {
+        type Nsid = Set<members::nsid>;
+        type Definitions = St::Definitions;
+        type CreatedAt = St::CreatedAt;
+        type Slice = St::Slice;
+    }
     ///State transition - sets the `definitions` field to Set
     pub struct SetDefinitions<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDefinitions<St> {}
     impl<St: State> State for SetDefinitions<St> {
+        type Nsid = St::Nsid;
         type Definitions = Set<members::definitions>;
         type CreatedAt = St::CreatedAt;
-        type Nsid = St::Nsid;
         type Slice = St::Slice;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Definitions = St::Definitions;
-        type CreatedAt = Set<members::created_at>;
         type Nsid = St::Nsid;
-        type Slice = St::Slice;
-    }
-    ///State transition - sets the `nsid` field to Set
-    pub struct SetNsid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNsid<St> {}
-    impl<St: State> State for SetNsid<St> {
         type Definitions = St::Definitions;
-        type CreatedAt = St::CreatedAt;
-        type Nsid = Set<members::nsid>;
+        type CreatedAt = Set<members::created_at>;
         type Slice = St::Slice;
     }
     ///State transition - sets the `slice` field to Set
     pub struct SetSlice<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlice<St> {}
     impl<St: State> State for SetSlice<St> {
+        type Nsid = St::Nsid;
         type Definitions = St::Definitions;
         type CreatedAt = St::CreatedAt;
-        type Nsid = St::Nsid;
         type Slice = Set<members::slice>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `nsid` field
+        pub struct nsid(());
         ///Marker type for the `definitions` field
         pub struct definitions(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `nsid` field
-        pub struct nsid(());
         ///Marker type for the `slice` field
         pub struct slice(());
     }
@@ -367,9 +367,9 @@ impl<S: BosStr, St: lexicon_state::State> LexiconBuilder<S, St> {
 impl<S: BosStr, St> LexiconBuilder<S, St>
 where
     St: lexicon_state::State,
+    St::Nsid: lexicon_state::IsSet,
     St::Definitions: lexicon_state::IsSet,
     St::CreatedAt: lexicon_state::IsSet,
-    St::Nsid: lexicon_state::IsSet,
     St::Slice: lexicon_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/network_slices/slice.rs b/crates/jacquard-api/src/network_slices/slice.rs
index 16ae480f..debe131c 100644
--- a/crates/jacquard-api/src/network_slices/slice.rs
+++ b/crates/jacquard-api/src/network_slices/slice.rs
@@ -476,105 +476,105 @@ pub mod slice_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
-        type Domain;
         type Name;
+        type Uri;
+        type Domain;
+        type Cid;
         type Creator;
         type CreatedAt;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
-        type Domain = Unset;
         type Name = Unset;
+        type Uri = Unset;
+        type Domain = Unset;
+        type Cid = Unset;
         type Creator = Unset;
         type CreatedAt = Unset;
-        type Uri = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
+        type Uri = St::Uri;
         type Domain = St::Domain;
+        type Cid = St::Cid;
+        type Creator = St::Creator;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
         type Name = St::Name;
+        type Uri = Set<members::uri>;
+        type Domain = St::Domain;
+        type Cid = St::Cid;
         type Creator = St::Creator;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `domain` field to Set
     pub struct SetDomain<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDomain<St> {}
     impl<St: State> State for SetDomain<St> {
-        type Cid = St::Cid;
-        type Domain = Set<members::domain>;
         type Name = St::Name;
+        type Uri = St::Uri;
+        type Domain = Set<members::domain>;
+        type Cid = St::Cid;
         type Creator = St::Creator;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Cid = St::Cid;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Name = St::Name;
+        type Uri = St::Uri;
         type Domain = St::Domain;
-        type Name = Set<members::name>;
+        type Cid = Set<members::cid>;
         type Creator = St::Creator;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `creator` field to Set
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
-        type Cid = St::Cid;
-        type Domain = St::Domain;
         type Name = St::Name;
+        type Uri = St::Uri;
+        type Domain = St::Domain;
+        type Cid = St::Cid;
         type Creator = Set<members::creator>;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Cid = St::Cid;
-        type Domain = St::Domain;
         type Name = St::Name;
-        type Creator = St::Creator;
-        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Domain = St::Domain;
-        type Name = St::Name;
+        type Cid = St::Cid;
         type Creator = St::Creator;
-        type CreatedAt = St::CreatedAt;
-        type Uri = Set<members::uri>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `domain` field
-        pub struct domain(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `domain` field
+        pub struct domain(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `creator` field
         pub struct creator(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -830,12 +830,12 @@ impl<S: BosStr, St: slice_view_state::State> SliceViewBuilder<S, St> {
 impl<S: BosStr, St> SliceViewBuilder<S, St>
 where
     St: slice_view_state::State,
-    St::Cid: slice_view_state::IsSet,
-    St::Domain: slice_view_state::IsSet,
     St::Name: slice_view_state::IsSet,
+    St::Uri: slice_view_state::IsSet,
+    St::Domain: slice_view_state::IsSet,
+    St::Cid: slice_view_state::IsSet,
     St::Creator: slice_view_state::IsSet,
     St::CreatedAt: slice_view_state::IsSet,
-    St::Uri: slice_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SliceView<S> {
@@ -1049,37 +1049,37 @@ pub mod sparkline_point_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Count;
         type Timestamp;
+        type Count;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Count = Unset;
         type Timestamp = Unset;
-    }
-    ///State transition - sets the `count` field to Set
-    pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCount<St> {}
-    impl<St: State> State for SetCount<St> {
-        type Count = Set<members::count>;
-        type Timestamp = St::Timestamp;
+        type Count = Unset;
     }
     ///State transition - sets the `timestamp` field to Set
     pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTimestamp<St> {}
     impl<St: State> State for SetTimestamp<St> {
-        type Count = St::Count;
         type Timestamp = Set<members::timestamp>;
+        type Count = St::Count;
+    }
+    ///State transition - sets the `count` field to Set
+    pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCount<St> {}
+    impl<St: State> State for SetCount<St> {
+        type Timestamp = St::Timestamp;
+        type Count = Set<members::count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `count` field
-        pub struct count(());
         ///Marker type for the `timestamp` field
         pub struct timestamp(());
+        ///Marker type for the `count` field
+        pub struct count(());
     }
 }
 
@@ -1149,8 +1149,8 @@ where
 impl<S: BosStr, St> SparklinePointBuilder<S, St>
 where
     St: sparkline_point_state::State,
-    St::Count: sparkline_point_state::IsSet,
     St::Timestamp: sparkline_point_state::IsSet,
+    St::Count: sparkline_point_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SparklinePoint<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/create_o_auth_client.rs b/crates/jacquard-api/src/network_slices/slice/create_o_auth_client.rs
index 8cd13fc2..1b8322be 100644
--- a/crates/jacquard-api/src/network_slices/slice/create_o_auth_client.rs
+++ b/crates/jacquard-api/src/network_slices/slice/create_o_auth_client.rs
@@ -100,51 +100,51 @@ pub mod create_o_auth_client_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ClientName;
         type SliceUri;
         type RedirectUris;
+        type ClientName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ClientName = Unset;
         type SliceUri = Unset;
         type RedirectUris = Unset;
-    }
-    ///State transition - sets the `client_name` field to Set
-    pub struct SetClientName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetClientName<St> {}
-    impl<St: State> State for SetClientName<St> {
-        type ClientName = Set<members::client_name>;
-        type SliceUri = St::SliceUri;
-        type RedirectUris = St::RedirectUris;
+        type ClientName = Unset;
     }
     ///State transition - sets the `slice_uri` field to Set
     pub struct SetSliceUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSliceUri<St> {}
     impl<St: State> State for SetSliceUri<St> {
-        type ClientName = St::ClientName;
         type SliceUri = Set<members::slice_uri>;
         type RedirectUris = St::RedirectUris;
+        type ClientName = St::ClientName;
     }
     ///State transition - sets the `redirect_uris` field to Set
     pub struct SetRedirectUris<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRedirectUris<St> {}
     impl<St: State> State for SetRedirectUris<St> {
-        type ClientName = St::ClientName;
         type SliceUri = St::SliceUri;
         type RedirectUris = Set<members::redirect_uris>;
+        type ClientName = St::ClientName;
+    }
+    ///State transition - sets the `client_name` field to Set
+    pub struct SetClientName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetClientName<St> {}
+    impl<St: State> State for SetClientName<St> {
+        type SliceUri = St::SliceUri;
+        type RedirectUris = St::RedirectUris;
+        type ClientName = Set<members::client_name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `client_name` field
-        pub struct client_name(());
         ///Marker type for the `slice_uri` field
         pub struct slice_uri(());
         ///Marker type for the `redirect_uris` field
         pub struct redirect_uris(());
+        ///Marker type for the `client_name` field
+        pub struct client_name(());
     }
 }
 
@@ -335,9 +335,9 @@ impl<S: BosStr, St: create_o_auth_client_state::State> CreateOAuthClientBuilder<
 impl<S: BosStr, St> CreateOAuthClientBuilder<S, St>
 where
     St: create_o_auth_client_state::State,
-    St::ClientName: create_o_auth_client_state::IsSet,
     St::SliceUri: create_o_auth_client_state::IsSet,
     St::RedirectUris: create_o_auth_client_state::IsSet,
+    St::ClientName: create_o_auth_client_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CreateOAuthClient<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs b/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs
index 884ac12c..cd79a84a 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_job_logs.rs
@@ -124,75 +124,77 @@ pub mod log_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Id;
         type LogType;
         type CreatedAt;
         type Level;
         type Message;
-        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Id = Unset;
         type LogType = Unset;
         type CreatedAt = Unset;
         type Level = Unset;
         type Message = Unset;
-        type Id = Unset;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
+        type LogType = St::LogType;
+        type CreatedAt = St::CreatedAt;
+        type Level = St::Level;
+        type Message = St::Message;
     }
     ///State transition - sets the `log_type` field to Set
     pub struct SetLogType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLogType<St> {}
     impl<St: State> State for SetLogType<St> {
+        type Id = St::Id;
         type LogType = Set<members::log_type>;
         type CreatedAt = St::CreatedAt;
         type Level = St::Level;
         type Message = St::Message;
-        type Id = St::Id;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Id = St::Id;
         type LogType = St::LogType;
         type CreatedAt = Set<members::created_at>;
         type Level = St::Level;
         type Message = St::Message;
-        type Id = St::Id;
     }
     ///State transition - sets the `level` field to Set
     pub struct SetLevel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLevel<St> {}
     impl<St: State> State for SetLevel<St> {
+        type Id = St::Id;
         type LogType = St::LogType;
         type CreatedAt = St::CreatedAt;
         type Level = Set<members::level>;
         type Message = St::Message;
-        type Id = St::Id;
     }
     ///State transition - sets the `message` field to Set
     pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMessage<St> {}
     impl<St: State> State for SetMessage<St> {
-        type LogType = St::LogType;
-        type CreatedAt = St::CreatedAt;
-        type Level = St::Level;
-        type Message = Set<members::message>;
         type Id = St::Id;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
         type LogType = St::LogType;
         type CreatedAt = St::CreatedAt;
         type Level = St::Level;
-        type Message = St::Message;
-        type Id = Set<members::id>;
+        type Message = Set<members::message>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `log_type` field
         pub struct log_type(());
         ///Marker type for the `created_at` field
@@ -201,8 +203,6 @@ pub mod log_entry_state {
         pub struct level(());
         ///Marker type for the `message` field
         pub struct message(());
-        ///Marker type for the `id` field
-        pub struct id(());
     }
 }
 
@@ -391,11 +391,11 @@ impl<S: BosStr, St: log_entry_state::State> LogEntryBuilder<S, St> {
 impl<S: BosStr, St> LogEntryBuilder<S, St>
 where
     St: log_entry_state::State,
+    St::Id: log_entry_state::IsSet,
     St::LogType: log_entry_state::IsSet,
     St::CreatedAt: log_entry_state::IsSet,
     St::Level: log_entry_state::IsSet,
     St::Message: log_entry_state::IsSet,
-    St::Id: log_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LogEntry<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/get_job_status.rs b/crates/jacquard-api/src/network_slices/slice/get_job_status.rs
index 4c375bef..48f9d575 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_job_status.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_job_status.rs
@@ -154,8 +154,8 @@ pub mod job_status_state {
     pub trait State: sealed::Sealed {
         type Status;
         type RetryCount;
-        type JobId;
         type CreatedAt;
+        type JobId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -163,8 +163,8 @@ pub mod job_status_state {
     impl State for Empty {
         type Status = Unset;
         type RetryCount = Unset;
-        type JobId = Unset;
         type CreatedAt = Unset;
+        type JobId = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
@@ -172,8 +172,8 @@ pub mod job_status_state {
     impl<St: State> State for SetStatus<St> {
         type Status = Set<members::status>;
         type RetryCount = St::RetryCount;
-        type JobId = St::JobId;
         type CreatedAt = St::CreatedAt;
+        type JobId = St::JobId;
     }
     ///State transition - sets the `retry_count` field to Set
     pub struct SetRetryCount<St: State = Empty>(PhantomData<fn() -> St>);
@@ -181,17 +181,8 @@ pub mod job_status_state {
     impl<St: State> State for SetRetryCount<St> {
         type Status = St::Status;
         type RetryCount = Set<members::retry_count>;
-        type JobId = St::JobId;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `job_id` field to Set
-    pub struct SetJobId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetJobId<St> {}
-    impl<St: State> State for SetJobId<St> {
-        type Status = St::Status;
-        type RetryCount = St::RetryCount;
-        type JobId = Set<members::job_id>;
         type CreatedAt = St::CreatedAt;
+        type JobId = St::JobId;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -199,8 +190,17 @@ pub mod job_status_state {
     impl<St: State> State for SetCreatedAt<St> {
         type Status = St::Status;
         type RetryCount = St::RetryCount;
-        type JobId = St::JobId;
         type CreatedAt = Set<members::created_at>;
+        type JobId = St::JobId;
+    }
+    ///State transition - sets the `job_id` field to Set
+    pub struct SetJobId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetJobId<St> {}
+    impl<St: State> State for SetJobId<St> {
+        type Status = St::Status;
+        type RetryCount = St::RetryCount;
+        type CreatedAt = St::CreatedAt;
+        type JobId = Set<members::job_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -209,10 +209,10 @@ pub mod job_status_state {
         pub struct status(());
         ///Marker type for the `retry_count` field
         pub struct retry_count(());
-        ///Marker type for the `job_id` field
-        pub struct job_id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `job_id` field
+        pub struct job_id(());
     }
 }
 
@@ -389,8 +389,8 @@ where
     St: job_status_state::State,
     St::Status: job_status_state::IsSet,
     St::RetryCount: job_status_state::IsSet,
-    St::JobId: job_status_state::IsSet,
     St::CreatedAt: job_status_state::IsSet,
+    St::JobId: job_status_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> JobStatus<S> {
@@ -716,83 +716,83 @@ pub mod sync_job_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CollectionsSynced;
-        type TotalRecords;
-        type Success;
         type Message;
+        type Success;
+        type TotalRecords;
+        type CollectionsSynced;
         type ReposProcessed;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CollectionsSynced = Unset;
-        type TotalRecords = Unset;
-        type Success = Unset;
         type Message = Unset;
+        type Success = Unset;
+        type TotalRecords = Unset;
+        type CollectionsSynced = Unset;
         type ReposProcessed = Unset;
     }
-    ///State transition - sets the `collections_synced` field to Set
-    pub struct SetCollectionsSynced<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollectionsSynced<St> {}
-    impl<St: State> State for SetCollectionsSynced<St> {
-        type CollectionsSynced = Set<members::collections_synced>;
-        type TotalRecords = St::TotalRecords;
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type Message = Set<members::message>;
         type Success = St::Success;
-        type Message = St::Message;
-        type ReposProcessed = St::ReposProcessed;
-    }
-    ///State transition - sets the `total_records` field to Set
-    pub struct SetTotalRecords<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTotalRecords<St> {}
-    impl<St: State> State for SetTotalRecords<St> {
+        type TotalRecords = St::TotalRecords;
         type CollectionsSynced = St::CollectionsSynced;
-        type TotalRecords = Set<members::total_records>;
-        type Success = St::Success;
-        type Message = St::Message;
         type ReposProcessed = St::ReposProcessed;
     }
     ///State transition - sets the `success` field to Set
     pub struct SetSuccess<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSuccess<St> {}
     impl<St: State> State for SetSuccess<St> {
-        type CollectionsSynced = St::CollectionsSynced;
-        type TotalRecords = St::TotalRecords;
-        type Success = Set<members::success>;
         type Message = St::Message;
+        type Success = Set<members::success>;
+        type TotalRecords = St::TotalRecords;
+        type CollectionsSynced = St::CollectionsSynced;
         type ReposProcessed = St::ReposProcessed;
     }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
+    ///State transition - sets the `total_records` field to Set
+    pub struct SetTotalRecords<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTotalRecords<St> {}
+    impl<St: State> State for SetTotalRecords<St> {
+        type Message = St::Message;
+        type Success = St::Success;
+        type TotalRecords = Set<members::total_records>;
         type CollectionsSynced = St::CollectionsSynced;
-        type TotalRecords = St::TotalRecords;
+        type ReposProcessed = St::ReposProcessed;
+    }
+    ///State transition - sets the `collections_synced` field to Set
+    pub struct SetCollectionsSynced<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollectionsSynced<St> {}
+    impl<St: State> State for SetCollectionsSynced<St> {
+        type Message = St::Message;
         type Success = St::Success;
-        type Message = Set<members::message>;
+        type TotalRecords = St::TotalRecords;
+        type CollectionsSynced = Set<members::collections_synced>;
         type ReposProcessed = St::ReposProcessed;
     }
     ///State transition - sets the `repos_processed` field to Set
     pub struct SetReposProcessed<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReposProcessed<St> {}
     impl<St: State> State for SetReposProcessed<St> {
-        type CollectionsSynced = St::CollectionsSynced;
-        type TotalRecords = St::TotalRecords;
-        type Success = St::Success;
         type Message = St::Message;
+        type Success = St::Success;
+        type TotalRecords = St::TotalRecords;
+        type CollectionsSynced = St::CollectionsSynced;
         type ReposProcessed = Set<members::repos_processed>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collections_synced` field
-        pub struct collections_synced(());
-        ///Marker type for the `total_records` field
-        pub struct total_records(());
-        ///Marker type for the `success` field
-        pub struct success(());
         ///Marker type for the `message` field
         pub struct message(());
+        ///Marker type for the `success` field
+        pub struct success(());
+        ///Marker type for the `total_records` field
+        pub struct total_records(());
+        ///Marker type for the `collections_synced` field
+        pub struct collections_synced(());
         ///Marker type for the `repos_processed` field
         pub struct repos_processed(());
     }
@@ -921,10 +921,10 @@ where
 impl<S: BosStr, St> SyncJobResultBuilder<S, St>
 where
     St: sync_job_result_state::State,
-    St::CollectionsSynced: sync_job_result_state::IsSet,
-    St::TotalRecords: sync_job_result_state::IsSet,
-    St::Success: sync_job_result_state::IsSet,
     St::Message: sync_job_result_state::IsSet,
+    St::Success: sync_job_result_state::IsSet,
+    St::TotalRecords: sync_job_result_state::IsSet,
+    St::CollectionsSynced: sync_job_result_state::IsSet,
     St::ReposProcessed: sync_job_result_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs b/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs
index db7026f5..a3a2750d 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_o_auth_clients.rs
@@ -219,127 +219,127 @@ pub mod oauth_client_details_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedByDid;
         type ClientName;
+        type CreatedByDid;
+        type ResponseTypes;
+        type GrantTypes;
         type ClientId;
         type RedirectUris;
-        type GrantTypes;
         type CreatedAt;
-        type ResponseTypes;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedByDid = Unset;
         type ClientName = Unset;
+        type CreatedByDid = Unset;
+        type ResponseTypes = Unset;
+        type GrantTypes = Unset;
         type ClientId = Unset;
         type RedirectUris = Unset;
-        type GrantTypes = Unset;
         type CreatedAt = Unset;
-        type ResponseTypes = Unset;
+    }
+    ///State transition - sets the `client_name` field to Set
+    pub struct SetClientName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetClientName<St> {}
+    impl<St: State> State for SetClientName<St> {
+        type ClientName = Set<members::client_name>;
+        type CreatedByDid = St::CreatedByDid;
+        type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = St::GrantTypes;
+        type ClientId = St::ClientId;
+        type RedirectUris = St::RedirectUris;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_by_did` field to Set
     pub struct SetCreatedByDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedByDid<St> {}
     impl<St: State> State for SetCreatedByDid<St> {
-        type CreatedByDid = Set<members::created_by_did>;
         type ClientName = St::ClientName;
+        type CreatedByDid = Set<members::created_by_did>;
+        type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = St::GrantTypes;
         type ClientId = St::ClientId;
         type RedirectUris = St::RedirectUris;
-        type GrantTypes = St::GrantTypes;
         type CreatedAt = St::CreatedAt;
-        type ResponseTypes = St::ResponseTypes;
     }
-    ///State transition - sets the `client_name` field to Set
-    pub struct SetClientName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetClientName<St> {}
-    impl<St: State> State for SetClientName<St> {
+    ///State transition - sets the `response_types` field to Set
+    pub struct SetResponseTypes<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetResponseTypes<St> {}
+    impl<St: State> State for SetResponseTypes<St> {
+        type ClientName = St::ClientName;
         type CreatedByDid = St::CreatedByDid;
-        type ClientName = Set<members::client_name>;
+        type ResponseTypes = Set<members::response_types>;
+        type GrantTypes = St::GrantTypes;
         type ClientId = St::ClientId;
         type RedirectUris = St::RedirectUris;
-        type GrantTypes = St::GrantTypes;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `grant_types` field to Set
+    pub struct SetGrantTypes<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGrantTypes<St> {}
+    impl<St: State> State for SetGrantTypes<St> {
+        type ClientName = St::ClientName;
+        type CreatedByDid = St::CreatedByDid;
         type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = Set<members::grant_types>;
+        type ClientId = St::ClientId;
+        type RedirectUris = St::RedirectUris;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `client_id` field to Set
     pub struct SetClientId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClientId<St> {}
     impl<St: State> State for SetClientId<St> {
-        type CreatedByDid = St::CreatedByDid;
         type ClientName = St::ClientName;
+        type CreatedByDid = St::CreatedByDid;
+        type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = St::GrantTypes;
         type ClientId = Set<members::client_id>;
         type RedirectUris = St::RedirectUris;
-        type GrantTypes = St::GrantTypes;
         type CreatedAt = St::CreatedAt;
-        type ResponseTypes = St::ResponseTypes;
     }
     ///State transition - sets the `redirect_uris` field to Set
     pub struct SetRedirectUris<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRedirectUris<St> {}
     impl<St: State> State for SetRedirectUris<St> {
-        type CreatedByDid = St::CreatedByDid;
         type ClientName = St::ClientName;
-        type ClientId = St::ClientId;
-        type RedirectUris = Set<members::redirect_uris>;
-        type GrantTypes = St::GrantTypes;
-        type CreatedAt = St::CreatedAt;
-        type ResponseTypes = St::ResponseTypes;
-    }
-    ///State transition - sets the `grant_types` field to Set
-    pub struct SetGrantTypes<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGrantTypes<St> {}
-    impl<St: State> State for SetGrantTypes<St> {
         type CreatedByDid = St::CreatedByDid;
-        type ClientName = St::ClientName;
+        type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = St::GrantTypes;
         type ClientId = St::ClientId;
-        type RedirectUris = St::RedirectUris;
-        type GrantTypes = Set<members::grant_types>;
+        type RedirectUris = Set<members::redirect_uris>;
         type CreatedAt = St::CreatedAt;
-        type ResponseTypes = St::ResponseTypes;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type CreatedByDid = St::CreatedByDid;
         type ClientName = St::ClientName;
-        type ClientId = St::ClientId;
-        type RedirectUris = St::RedirectUris;
-        type GrantTypes = St::GrantTypes;
-        type CreatedAt = Set<members::created_at>;
-        type ResponseTypes = St::ResponseTypes;
-    }
-    ///State transition - sets the `response_types` field to Set
-    pub struct SetResponseTypes<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetResponseTypes<St> {}
-    impl<St: State> State for SetResponseTypes<St> {
         type CreatedByDid = St::CreatedByDid;
-        type ClientName = St::ClientName;
+        type ResponseTypes = St::ResponseTypes;
+        type GrantTypes = St::GrantTypes;
         type ClientId = St::ClientId;
         type RedirectUris = St::RedirectUris;
-        type GrantTypes = St::GrantTypes;
-        type CreatedAt = St::CreatedAt;
-        type ResponseTypes = Set<members::response_types>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_by_did` field
-        pub struct created_by_did(());
         ///Marker type for the `client_name` field
         pub struct client_name(());
+        ///Marker type for the `created_by_did` field
+        pub struct created_by_did(());
+        ///Marker type for the `response_types` field
+        pub struct response_types(());
+        ///Marker type for the `grant_types` field
+        pub struct grant_types(());
         ///Marker type for the `client_id` field
         pub struct client_id(());
         ///Marker type for the `redirect_uris` field
         pub struct redirect_uris(());
-        ///Marker type for the `grant_types` field
-        pub struct grant_types(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `response_types` field
-        pub struct response_types(());
     }
 }
 
@@ -610,13 +610,13 @@ impl<S: BosStr, St: oauth_client_details_state::State> OauthClientDetailsBuilder
 impl<S: BosStr, St> OauthClientDetailsBuilder<S, St>
 where
     St: oauth_client_details_state::State,
-    St::CreatedByDid: oauth_client_details_state::IsSet,
     St::ClientName: oauth_client_details_state::IsSet,
+    St::CreatedByDid: oauth_client_details_state::IsSet,
+    St::ResponseTypes: oauth_client_details_state::IsSet,
+    St::GrantTypes: oauth_client_details_state::IsSet,
     St::ClientId: oauth_client_details_state::IsSet,
     St::RedirectUris: oauth_client_details_state::IsSet,
-    St::GrantTypes: oauth_client_details_state::IsSet,
     St::CreatedAt: oauth_client_details_state::IsSet,
-    St::ResponseTypes: oauth_client_details_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> OauthClientDetails<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs b/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs
index c722e89d..b80d9ac3 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_slice_records.rs
@@ -133,105 +133,105 @@ pub mod indexed_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type Value;
+        type IndexedAt;
         type Cid;
         type Did;
         type Collection;
-        type Uri;
-        type IndexedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type Value = Unset;
+        type IndexedAt = Unset;
         type Cid = Unset;
         type Did = Unset;
         type Collection = Unset;
-        type Uri = Unset;
-        type IndexedAt = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Value = St::Value;
+        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Did = St::Did;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
+        type Uri = St::Uri;
         type Value = Set<members::value>;
+        type IndexedAt = St::IndexedAt;
         type Cid = St::Cid;
         type Did = St::Did;
         type Collection = St::Collection;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
+        type Value = St::Value;
+        type IndexedAt = Set<members::indexed_at>;
+        type Cid = St::Cid;
+        type Did = St::Did;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
         type Value = St::Value;
+        type IndexedAt = St::IndexedAt;
         type Cid = Set<members::cid>;
         type Did = St::Did;
         type Collection = St::Collection;
-        type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
+        type Uri = St::Uri;
         type Value = St::Value;
+        type IndexedAt = St::IndexedAt;
         type Cid = St::Cid;
         type Did = Set<members::did>;
         type Collection = St::Collection;
-        type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Value = St::Value;
-        type Cid = St::Cid;
-        type Did = St::Did;
-        type Collection = Set<members::collection>;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Value = St::Value;
-        type Cid = St::Cid;
-        type Did = St::Did;
-        type Collection = St::Collection;
-        type Uri = Set<members::uri>;
         type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Value = St::Value;
         type Cid = St::Cid;
         type Did = St::Did;
-        type Collection = St::Collection;
-        type Uri = St::Uri;
-        type IndexedAt = Set<members::indexed_at>;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `value` field
         pub struct value(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `collection` field
         pub struct collection(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
     }
 }
 
@@ -384,12 +384,12 @@ where
 impl<S: BosStr, St> IndexedRecordBuilder<S, St>
 where
     St: indexed_record_state::State,
+    St::Uri: indexed_record_state::IsSet,
     St::Value: indexed_record_state::IsSet,
+    St::IndexedAt: indexed_record_state::IsSet,
     St::Cid: indexed_record_state::IsSet,
     St::Did: indexed_record_state::IsSet,
     St::Collection: indexed_record_state::IsSet,
-    St::Uri: indexed_record_state::IsSet,
-    St::IndexedAt: indexed_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> IndexedRecord<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs b/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs
index 194d5652..fc105b6c 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_sparklines.rs
@@ -256,37 +256,37 @@ pub mod sparkline_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Points;
         type SliceUri;
+        type Points;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Points = Unset;
         type SliceUri = Unset;
-    }
-    ///State transition - sets the `points` field to Set
-    pub struct SetPoints<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPoints<St> {}
-    impl<St: State> State for SetPoints<St> {
-        type Points = Set<members::points>;
-        type SliceUri = St::SliceUri;
+        type Points = Unset;
     }
     ///State transition - sets the `slice_uri` field to Set
     pub struct SetSliceUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSliceUri<St> {}
     impl<St: State> State for SetSliceUri<St> {
-        type Points = St::Points;
         type SliceUri = Set<members::slice_uri>;
+        type Points = St::Points;
+    }
+    ///State transition - sets the `points` field to Set
+    pub struct SetPoints<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPoints<St> {}
+    impl<St: State> State for SetPoints<St> {
+        type SliceUri = St::SliceUri;
+        type Points = Set<members::points>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `points` field
-        pub struct points(());
         ///Marker type for the `slice_uri` field
         pub struct slice_uri(());
+        ///Marker type for the `points` field
+        pub struct points(());
     }
 }
 
@@ -356,8 +356,8 @@ where
 impl<S: BosStr, St> SparklineEntryBuilder<S, St>
 where
     St: sparkline_entry_state::State,
-    St::Points: sparkline_entry_state::IsSet,
     St::SliceUri: sparkline_entry_state::IsSet,
+    St::Points: sparkline_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SparklineEntry<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs b/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs
index 0ea858d1..24004c38 100644
--- a/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs
+++ b/crates/jacquard-api/src/network_slices/slice/get_sync_summary.rs
@@ -114,51 +114,51 @@ pub mod collection_summary_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type EstimatedRepos;
         type IsExternal;
         type Collection;
-        type EstimatedRepos;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type EstimatedRepos = Unset;
         type IsExternal = Unset;
         type Collection = Unset;
-        type EstimatedRepos = Unset;
+    }
+    ///State transition - sets the `estimated_repos` field to Set
+    pub struct SetEstimatedRepos<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEstimatedRepos<St> {}
+    impl<St: State> State for SetEstimatedRepos<St> {
+        type EstimatedRepos = Set<members::estimated_repos>;
+        type IsExternal = St::IsExternal;
+        type Collection = St::Collection;
     }
     ///State transition - sets the `is_external` field to Set
     pub struct SetIsExternal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIsExternal<St> {}
     impl<St: State> State for SetIsExternal<St> {
+        type EstimatedRepos = St::EstimatedRepos;
         type IsExternal = Set<members::is_external>;
         type Collection = St::Collection;
-        type EstimatedRepos = St::EstimatedRepos;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type IsExternal = St::IsExternal;
-        type Collection = Set<members::collection>;
         type EstimatedRepos = St::EstimatedRepos;
-    }
-    ///State transition - sets the `estimated_repos` field to Set
-    pub struct SetEstimatedRepos<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEstimatedRepos<St> {}
-    impl<St: State> State for SetEstimatedRepos<St> {
         type IsExternal = St::IsExternal;
-        type Collection = St::Collection;
-        type EstimatedRepos = Set<members::estimated_repos>;
+        type Collection = Set<members::collection>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `estimated_repos` field
+        pub struct estimated_repos(());
         ///Marker type for the `is_external` field
         pub struct is_external(());
         ///Marker type for the `collection` field
         pub struct collection(());
-        ///Marker type for the `estimated_repos` field
-        pub struct estimated_repos(());
     }
 }
 
@@ -247,9 +247,9 @@ where
 impl<S: BosStr, St> CollectionSummaryBuilder<S, St>
 where
     St: collection_summary_state::State,
+    St::EstimatedRepos: collection_summary_state::IsSet,
     St::IsExternal: collection_summary_state::IsSet,
     St::Collection: collection_summary_state::IsSet,
-    St::EstimatedRepos: collection_summary_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionSummary<S> {
diff --git a/crates/jacquard-api/src/network_slices/slice/stats.rs b/crates/jacquard-api/src/network_slices/slice/stats.rs
index 0d16b26a..765b748a 100644
--- a/crates/jacquard-api/src/network_slices/slice/stats.rs
+++ b/crates/jacquard-api/src/network_slices/slice/stats.rs
@@ -114,50 +114,50 @@ pub mod collection_stats_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Collection;
-        type RecordCount;
         type UniqueActors;
+        type RecordCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Collection = Unset;
-        type RecordCount = Unset;
         type UniqueActors = Unset;
+        type RecordCount = Unset;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
         type Collection = Set<members::collection>;
-        type RecordCount = St::RecordCount;
-        type UniqueActors = St::UniqueActors;
-    }
-    ///State transition - sets the `record_count` field to Set
-    pub struct SetRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecordCount<St> {}
-    impl<St: State> State for SetRecordCount<St> {
-        type Collection = St::Collection;
-        type RecordCount = Set<members::record_count>;
         type UniqueActors = St::UniqueActors;
+        type RecordCount = St::RecordCount;
     }
     ///State transition - sets the `unique_actors` field to Set
     pub struct SetUniqueActors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUniqueActors<St> {}
     impl<St: State> State for SetUniqueActors<St> {
         type Collection = St::Collection;
-        type RecordCount = St::RecordCount;
         type UniqueActors = Set<members::unique_actors>;
+        type RecordCount = St::RecordCount;
+    }
+    ///State transition - sets the `record_count` field to Set
+    pub struct SetRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecordCount<St> {}
+    impl<St: State> State for SetRecordCount<St> {
+        type Collection = St::Collection;
+        type UniqueActors = St::UniqueActors;
+        type RecordCount = Set<members::record_count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `collection` field
         pub struct collection(());
-        ///Marker type for the `record_count` field
-        pub struct record_count(());
         ///Marker type for the `unique_actors` field
         pub struct unique_actors(());
+        ///Marker type for the `record_count` field
+        pub struct record_count(());
     }
 }
 
@@ -247,8 +247,8 @@ impl<S: BosStr, St> CollectionStatsBuilder<S, St>
 where
     St: collection_stats_state::State,
     St::Collection: collection_stats_state::IsSet,
-    St::RecordCount: collection_stats_state::IsSet,
     St::UniqueActors: collection_stats_state::IsSet,
+    St::RecordCount: collection_stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionStats<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools.rs b/crates/jacquard-api/src/network_slices/tools.rs
index f9faa41d..5584d9e0 100644
--- a/crates/jacquard-api/src/network_slices/tools.rs
+++ b/crates/jacquard-api/src/network_slices/tools.rs
@@ -141,37 +141,37 @@ pub mod image_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type Alt;
+        type Image;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type Alt = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type Alt = St::Alt;
+        type Image = Unset;
     }
     ///State transition - sets the `alt` field to Set
     pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlt<St> {}
     impl<St: State> State for SetAlt<St> {
-        type Image = St::Image;
         type Alt = Set<members::alt>;
+        type Image = St::Image;
+    }
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
+        type Alt = St::Alt;
+        type Image = Set<members::image>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `alt` field
         pub struct alt(());
+        ///Marker type for the `image` field
+        pub struct image(());
     }
 }
 
@@ -241,8 +241,8 @@ where
 impl<S: BosStr, St> ImageBuilder<S, St>
 where
     St: image_state::State,
-    St::Image: image_state::IsSet,
     St::Alt: image_state::IsSet,
+    St::Image: image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Image<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools/bug.rs b/crates/jacquard-api/src/network_slices/tools/bug.rs
index 8cdb97f5..f404499c 100644
--- a/crates/jacquard-api/src/network_slices/tools/bug.rs
+++ b/crates/jacquard-api/src/network_slices/tools/bug.rs
@@ -301,105 +301,105 @@ pub mod bug_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Namespace;
+        type Title;
         type Severity;
         type CreatedAt;
         type StepsToReproduce;
-        type Title;
         type Description;
-        type Namespace;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Namespace = Unset;
+        type Title = Unset;
         type Severity = Unset;
         type CreatedAt = Unset;
         type StepsToReproduce = Unset;
-        type Title = Unset;
         type Description = Unset;
-        type Namespace = Unset;
+    }
+    ///State transition - sets the `namespace` field to Set
+    pub struct SetNamespace<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNamespace<St> {}
+    impl<St: State> State for SetNamespace<St> {
+        type Namespace = Set<members::namespace>;
+        type Title = St::Title;
+        type Severity = St::Severity;
+        type CreatedAt = St::CreatedAt;
+        type StepsToReproduce = St::StepsToReproduce;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Namespace = St::Namespace;
+        type Title = Set<members::title>;
+        type Severity = St::Severity;
+        type CreatedAt = St::CreatedAt;
+        type StepsToReproduce = St::StepsToReproduce;
+        type Description = St::Description;
     }
     ///State transition - sets the `severity` field to Set
     pub struct SetSeverity<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeverity<St> {}
     impl<St: State> State for SetSeverity<St> {
+        type Namespace = St::Namespace;
+        type Title = St::Title;
         type Severity = Set<members::severity>;
         type CreatedAt = St::CreatedAt;
         type StepsToReproduce = St::StepsToReproduce;
-        type Title = St::Title;
         type Description = St::Description;
-        type Namespace = St::Namespace;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Namespace = St::Namespace;
+        type Title = St::Title;
         type Severity = St::Severity;
         type CreatedAt = Set<members::created_at>;
         type StepsToReproduce = St::StepsToReproduce;
-        type Title = St::Title;
         type Description = St::Description;
-        type Namespace = St::Namespace;
     }
     ///State transition - sets the `steps_to_reproduce` field to Set
     pub struct SetStepsToReproduce<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStepsToReproduce<St> {}
     impl<St: State> State for SetStepsToReproduce<St> {
-        type Severity = St::Severity;
-        type CreatedAt = St::CreatedAt;
-        type StepsToReproduce = Set<members::steps_to_reproduce>;
-        type Title = St::Title;
-        type Description = St::Description;
         type Namespace = St::Namespace;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
+        type Title = St::Title;
         type Severity = St::Severity;
         type CreatedAt = St::CreatedAt;
-        type StepsToReproduce = St::StepsToReproduce;
-        type Title = Set<members::title>;
+        type StepsToReproduce = Set<members::steps_to_reproduce>;
         type Description = St::Description;
-        type Namespace = St::Namespace;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type Severity = St::Severity;
-        type CreatedAt = St::CreatedAt;
-        type StepsToReproduce = St::StepsToReproduce;
-        type Title = St::Title;
-        type Description = Set<members::description>;
         type Namespace = St::Namespace;
-    }
-    ///State transition - sets the `namespace` field to Set
-    pub struct SetNamespace<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNamespace<St> {}
-    impl<St: State> State for SetNamespace<St> {
+        type Title = St::Title;
         type Severity = St::Severity;
         type CreatedAt = St::CreatedAt;
         type StepsToReproduce = St::StepsToReproduce;
-        type Title = St::Title;
-        type Description = St::Description;
-        type Namespace = Set<members::namespace>;
+        type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `namespace` field
+        pub struct namespace(());
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `severity` field
         pub struct severity(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `steps_to_reproduce` field
         pub struct steps_to_reproduce(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `description` field
         pub struct description(());
-        ///Marker type for the `namespace` field
-        pub struct namespace(());
     }
 }
 
@@ -617,12 +617,12 @@ where
 impl<S: BosStr, St> BugBuilder<S, St>
 where
     St: bug_state::State,
+    St::Namespace: bug_state::IsSet,
+    St::Title: bug_state::IsSet,
     St::Severity: bug_state::IsSet,
     St::CreatedAt: bug_state::IsSet,
     St::StepsToReproduce: bug_state::IsSet,
-    St::Title: bug_state::IsSet,
     St::Description: bug_state::IsSet,
-    St::Namespace: bug_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Bug<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools/bug/issue.rs b/crates/jacquard-api/src/network_slices/tools/bug/issue.rs
index 42e1ef4f..41877c5e 100644
--- a/crates/jacquard-api/src/network_slices/tools/bug/issue.rs
+++ b/crates/jacquard-api/src/network_slices/tools/bug/issue.rs
@@ -114,51 +114,51 @@ pub mod issue_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Bug;
         type Issue;
         type CreatedAt;
-        type Bug;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Bug = Unset;
         type Issue = Unset;
         type CreatedAt = Unset;
-        type Bug = Unset;
+    }
+    ///State transition - sets the `bug` field to Set
+    pub struct SetBug<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBug<St> {}
+    impl<St: State> State for SetBug<St> {
+        type Bug = Set<members::bug>;
+        type Issue = St::Issue;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `issue` field to Set
     pub struct SetIssue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIssue<St> {}
     impl<St: State> State for SetIssue<St> {
+        type Bug = St::Bug;
         type Issue = Set<members::issue>;
         type CreatedAt = St::CreatedAt;
-        type Bug = St::Bug;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Issue = St::Issue;
-        type CreatedAt = Set<members::created_at>;
         type Bug = St::Bug;
-    }
-    ///State transition - sets the `bug` field to Set
-    pub struct SetBug<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBug<St> {}
-    impl<St: State> State for SetBug<St> {
         type Issue = St::Issue;
-        type CreatedAt = St::CreatedAt;
-        type Bug = Set<members::bug>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `bug` field
+        pub struct bug(());
         ///Marker type for the `issue` field
         pub struct issue(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `bug` field
-        pub struct bug(());
     }
 }
 
@@ -247,9 +247,9 @@ where
 impl<S: BosStr, St> IssueBuilder<S, St>
 where
     St: issue_state::State,
+    St::Bug: issue_state::IsSet,
     St::Issue: issue_state::IsSet,
     St::CreatedAt: issue_state::IsSet,
-    St::Bug: issue_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Issue<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools/bug/response.rs b/crates/jacquard-api/src/network_slices/tools/bug/response.rs
index 595d98e7..d5345c83 100644
--- a/crates/jacquard-api/src/network_slices/tools/bug/response.rs
+++ b/crates/jacquard-api/src/network_slices/tools/bug/response.rs
@@ -232,51 +232,51 @@ pub mod response_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Bug;
         type Status;
+        type Bug;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Bug = Unset;
         type Status = Unset;
+        type Bug = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Status = Set<members::status>;
         type Bug = St::Bug;
-        type Status = St::Status;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `bug` field to Set
     pub struct SetBug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBug<St> {}
     impl<St: State> State for SetBug<St> {
-        type CreatedAt = St::CreatedAt;
-        type Bug = Set<members::bug>;
         type Status = St::Status;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
+        type Bug = Set<members::bug>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Status = St::Status;
         type Bug = St::Bug;
-        type Status = Set<members::status>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `bug` field
-        pub struct bug(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `bug` field
+        pub struct bug(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -397,9 +397,9 @@ where
 impl<S: BosStr, St> ResponseBuilder<S, St>
 where
     St: response_state::State,
-    St::CreatedAt: response_state::IsSet,
-    St::Bug: response_state::IsSet,
     St::Status: response_state::IsSet,
+    St::Bug: response_state::IsSet,
+    St::CreatedAt: response_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Response<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools/document.rs b/crates/jacquard-api/src/network_slices/tools/document.rs
index ac3ff9c3..b66a002e 100644
--- a/crates/jacquard-api/src/network_slices/tools/document.rs
+++ b/crates/jacquard-api/src/network_slices/tools/document.rs
@@ -1037,67 +1037,67 @@ pub mod document_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Blocks;
-        type CreatedAt;
         type Slug;
+        type Title;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Blocks = Unset;
-        type CreatedAt = Unset;
         type Slug = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Blocks = St::Blocks;
-        type CreatedAt = St::CreatedAt;
-        type Slug = St::Slug;
+        type Title = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `blocks` field to Set
     pub struct SetBlocks<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlocks<St> {}
     impl<St: State> State for SetBlocks<St> {
-        type Title = St::Title;
         type Blocks = Set<members::blocks>;
-        type CreatedAt = St::CreatedAt;
         type Slug = St::Slug;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Title = St::Title;
-        type Blocks = St::Blocks;
-        type CreatedAt = Set<members::created_at>;
-        type Slug = St::Slug;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlug<St> {}
     impl<St: State> State for SetSlug<St> {
+        type Blocks = St::Blocks;
+        type Slug = Set<members::slug>;
         type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
         type Blocks = St::Blocks;
+        type Slug = St::Slug;
+        type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
-        type Slug = Set<members::slug>;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Blocks = St::Blocks;
+        type Slug = St::Slug;
+        type Title = St::Title;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `blocks` field
         pub struct blocks(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -1224,10 +1224,10 @@ impl<S: BosStr, St: document_state::State> DocumentBuilder<S, St> {
 impl<S: BosStr, St> DocumentBuilder<S, St>
 where
     St: document_state::State,
-    St::Title: document_state::IsSet,
     St::Blocks: document_state::IsSet,
-    St::CreatedAt: document_state::IsSet,
     St::Slug: document_state::IsSet,
+    St::Title: document_state::IsSet,
+    St::CreatedAt: document_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Document<S> {
diff --git a/crates/jacquard-api/src/network_slices/tools/richtext/facet.rs b/crates/jacquard-api/src/network_slices/tools/richtext/facet.rs
index 7c9adc4a..5aa0f53e 100644
--- a/crates/jacquard-api/src/network_slices/tools/richtext/facet.rs
+++ b/crates/jacquard-api/src/network_slices/tools/richtext/facet.rs
@@ -664,37 +664,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Features;
         type Index;
+        type Features;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Features = Unset;
         type Index = Unset;
-    }
-    ///State transition - sets the `features` field to Set
-    pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFeatures<St> {}
-    impl<St: State> State for SetFeatures<St> {
-        type Features = Set<members::features>;
-        type Index = St::Index;
+        type Features = Unset;
     }
     ///State transition - sets the `index` field to Set
     pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndex<St> {}
     impl<St: State> State for SetIndex<St> {
-        type Features = St::Features;
         type Index = Set<members::index>;
+        type Features = St::Features;
+    }
+    ///State transition - sets the `features` field to Set
+    pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFeatures<St> {}
+    impl<St: State> State for SetFeatures<St> {
+        type Index = St::Index;
+        type Features = Set<members::features>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `features` field
-        pub struct features(());
         ///Marker type for the `index` field
         pub struct index(());
+        ///Marker type for the `features` field
+        pub struct features(());
     }
 }
 
@@ -764,8 +764,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Features: facet_state::IsSet,
     St::Index: facet_state::IsSet,
+    St::Features: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/network_slices/waitlist.rs b/crates/jacquard-api/src/network_slices/waitlist.rs
index 96283538..5acd9c79 100644
--- a/crates/jacquard-api/src/network_slices/waitlist.rs
+++ b/crates/jacquard-api/src/network_slices/waitlist.rs
@@ -110,50 +110,50 @@ pub mod invite_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Slice;
-        type CreatedAt;
         type Did;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Slice = Unset;
-        type CreatedAt = Unset;
         type Did = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `slice` field to Set
     pub struct SetSlice<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlice<St> {}
     impl<St: State> State for SetSlice<St> {
         type Slice = Set<members::slice>;
-        type CreatedAt = St::CreatedAt;
-        type Did = St::Did;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Slice = St::Slice;
-        type CreatedAt = Set<members::created_at>;
         type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
         type Slice = St::Slice;
-        type CreatedAt = St::CreatedAt;
         type Did = Set<members::did>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Slice = St::Slice;
+        type Did = St::Did;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `slice` field
         pub struct slice(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -289,8 +289,8 @@ impl<S: BosStr, St> InviteViewBuilder<S, St>
 where
     St: invite_view_state::State,
     St::Slice: invite_view_state::IsSet,
-    St::CreatedAt: invite_view_state::IsSet,
     St::Did: invite_view_state::IsSet,
+    St::CreatedAt: invite_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> InviteView<S> {
diff --git a/crates/jacquard-api/src/network_slices/waitlist/invite.rs b/crates/jacquard-api/src/network_slices/waitlist/invite.rs
index c89a2267..6d6abdee 100644
--- a/crates/jacquard-api/src/network_slices/waitlist/invite.rs
+++ b/crates/jacquard-api/src/network_slices/waitlist/invite.rs
@@ -119,49 +119,49 @@ pub mod invite_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type CreatedAt;
+        type Did;
         type Slice;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type CreatedAt = Unset;
+        type Did = Unset;
         type Slice = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type CreatedAt = St::CreatedAt;
-        type Slice = St::Slice;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Did = St::Did;
         type CreatedAt = Set<members::created_at>;
+        type Did = St::Did;
+        type Slice = St::Slice;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type CreatedAt = St::CreatedAt;
+        type Did = Set<members::did>;
         type Slice = St::Slice;
     }
     ///State transition - sets the `slice` field to Set
     pub struct SetSlice<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlice<St> {}
     impl<St: State> State for SetSlice<St> {
-        type Did = St::Did;
         type CreatedAt = St::CreatedAt;
+        type Did = St::Did;
         type Slice = Set<members::slice>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `slice` field
         pub struct slice(());
     }
@@ -265,8 +265,8 @@ where
 impl<S: BosStr, St> InviteBuilder<S, St>
 where
     St: invite_state::State,
-    St::Did: invite_state::IsSet,
     St::CreatedAt: invite_state::IsSet,
+    St::Did: invite_state::IsSet,
     St::Slice: invite_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/network_slices/waitlist/request.rs b/crates/jacquard-api/src/network_slices/waitlist/request.rs
index 3c06e994..7a93753f 100644
--- a/crates/jacquard-api/src/network_slices/waitlist/request.rs
+++ b/crates/jacquard-api/src/network_slices/waitlist/request.rs
@@ -114,37 +114,37 @@ pub mod request_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Slice;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Slice = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Slice = St::Slice;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `slice` field to Set
     pub struct SetSlice<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlice<St> {}
     impl<St: State> State for SetSlice<St> {
-        type CreatedAt = St::CreatedAt;
         type Slice = Set<members::slice>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Slice = St::Slice;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `slice` field
         pub struct slice(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> RequestBuilder<S, St>
 where
     St: request_state::State,
-    St::CreatedAt: request_state::IsSet,
     St::Slice: request_state::IsSet,
+    St::CreatedAt: request_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Request<S> {
diff --git a/crates/jacquard-api/src/ooo_bsky/authfetch/fetch_records.rs b/crates/jacquard-api/src/ooo_bsky/authfetch/fetch_records.rs
index 7d911bac..a8da8616 100644
--- a/crates/jacquard-api/src/ooo_bsky/authfetch/fetch_records.rs
+++ b/crates/jacquard-api/src/ooo_bsky/authfetch/fetch_records.rs
@@ -196,51 +196,51 @@ pub mod fetch_records_result_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type Strategy;
         type Record;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type Strategy = Unset;
         type Record = Unset;
-        type Uri = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Strategy = St::Strategy;
+        type Record = St::Record;
     }
     ///State transition - sets the `strategy` field to Set
     pub struct SetStrategy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStrategy<St> {}
     impl<St: State> State for SetStrategy<St> {
+        type Uri = St::Uri;
         type Strategy = Set<members::strategy>;
         type Record = St::Record;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Strategy = St::Strategy;
-        type Record = Set<members::record>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Strategy = St::Strategy;
-        type Record = St::Record;
-        type Uri = Set<members::uri>;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `strategy` field
         pub struct strategy(());
         ///Marker type for the `record` field
         pub struct record(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -329,9 +329,9 @@ where
 impl<S: BosStr, St> FetchRecordsResultBuilder<S, St>
 where
     St: fetch_records_result_state::State,
+    St::Uri: fetch_records_result_state::IsSet,
     St::Strategy: fetch_records_result_state::IsSet,
     St::Record: fetch_records_result_state::IsSet,
-    St::Uri: fetch_records_result_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FetchRecordsResult<S> {
diff --git a/crates/jacquard-api/src/ooo_bsky/authfetch/import_repo.rs b/crates/jacquard-api/src/ooo_bsky/authfetch/import_repo.rs
index 321ddb63..2098c5b3 100644
--- a/crates/jacquard-api/src/ooo_bsky/authfetch/import_repo.rs
+++ b/crates/jacquard-api/src/ooo_bsky/authfetch/import_repo.rs
@@ -40,7 +40,7 @@ impl jacquard_common::xrpc::XrpcRequest for ImportRepo {
     type Response = ImportRepoResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/ooo_bsky/authfetch/list_records.rs b/crates/jacquard-api/src/ooo_bsky/authfetch/list_records.rs
index fcdb8b4a..31d82650 100644
--- a/crates/jacquard-api/src/ooo_bsky/authfetch/list_records.rs
+++ b/crates/jacquard-api/src/ooo_bsky/authfetch/list_records.rs
@@ -251,51 +251,51 @@ pub mod record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Strategy;
-        type Uri;
         type Value;
+        type Uri;
+        type Strategy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Strategy = Unset;
-        type Uri = Unset;
         type Value = Unset;
+        type Uri = Unset;
+        type Strategy = Unset;
     }
-    ///State transition - sets the `strategy` field to Set
-    pub struct SetStrategy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStrategy<St> {}
-    impl<St: State> State for SetStrategy<St> {
-        type Strategy = Set<members::strategy>;
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Value = Set<members::value>;
         type Uri = St::Uri;
-        type Value = St::Value;
+        type Strategy = St::Strategy;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Strategy = St::Strategy;
-        type Uri = Set<members::uri>;
         type Value = St::Value;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
+        type Uri = Set<members::uri>;
         type Strategy = St::Strategy;
+    }
+    ///State transition - sets the `strategy` field to Set
+    pub struct SetStrategy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStrategy<St> {}
+    impl<St: State> State for SetStrategy<St> {
+        type Value = St::Value;
         type Uri = St::Uri;
-        type Value = Set<members::value>;
+        type Strategy = Set<members::strategy>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `strategy` field
-        pub struct strategy(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `value` field
         pub struct value(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `strategy` field
+        pub struct strategy(());
     }
 }
 
@@ -384,9 +384,9 @@ where
 impl<S: BosStr, St> RecordBuilder<S, St>
 where
     St: record_state::State,
-    St::Strategy: record_state::IsSet,
-    St::Uri: record_state::IsSet,
     St::Value: record_state::IsSet,
+    St::Uri: record_state::IsSet,
+    St::Strategy: record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Record<S> {
diff --git a/crates/jacquard-api/src/ooo_bsky/authfetch/put_record.rs b/crates/jacquard-api/src/ooo_bsky/authfetch/put_record.rs
index 10eb096e..7c973cc3 100644
--- a/crates/jacquard-api/src/ooo_bsky/authfetch/put_record.rs
+++ b/crates/jacquard-api/src/ooo_bsky/authfetch/put_record.rs
@@ -81,67 +81,67 @@ pub mod put_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Collection;
+        type Record;
         type Rkey;
+        type Collection;
         type Strategy;
-        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Collection = Unset;
+        type Record = Unset;
         type Rkey = Unset;
+        type Collection = Unset;
         type Strategy = Unset;
-        type Record = Unset;
     }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Record = Set<members::record>;
         type Rkey = St::Rkey;
+        type Collection = St::Collection;
         type Strategy = St::Strategy;
-        type Record = St::Record;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Collection = St::Collection;
+        type Record = St::Record;
         type Rkey = Set<members::rkey>;
+        type Collection = St::Collection;
         type Strategy = St::Strategy;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
         type Record = St::Record;
+        type Rkey = St::Rkey;
+        type Collection = Set<members::collection>;
+        type Strategy = St::Strategy;
     }
     ///State transition - sets the `strategy` field to Set
     pub struct SetStrategy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStrategy<St> {}
     impl<St: State> State for SetStrategy<St> {
-        type Collection = St::Collection;
-        type Rkey = St::Rkey;
-        type Strategy = Set<members::strategy>;
         type Record = St::Record;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Collection = St::Collection;
         type Rkey = St::Rkey;
-        type Strategy = St::Strategy;
-        type Record = Set<members::record>;
+        type Collection = St::Collection;
+        type Strategy = Set<members::strategy>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collection` field
-        pub struct collection(());
+        ///Marker type for the `record` field
+        pub struct record(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
         ///Marker type for the `strategy` field
         pub struct strategy(());
-        ///Marker type for the `record` field
-        pub struct record(());
     }
 }
 
@@ -254,10 +254,10 @@ where
 impl<S: BosStr, St> PutRecordBuilder<S, St>
 where
     St: put_record_state::State,
-    St::Collection: put_record_state::IsSet,
+    St::Record: put_record_state::IsSet,
     St::Rkey: put_record_state::IsSet,
+    St::Collection: put_record_state::IsSet,
     St::Strategy: put_record_state::IsSet,
-    St::Record: put_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PutRecord<S> {
diff --git a/crates/jacquard-api/src/org_atpodcasting/episode.rs b/crates/jacquard-api/src/org_atpodcasting/episode.rs
index b184c451..e28c0f41 100644
--- a/crates/jacquard-api/src/org_atpodcasting/episode.rs
+++ b/crates/jacquard-api/src/org_atpodcasting/episode.rs
@@ -447,37 +447,37 @@ pub mod chapters_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MimeType;
         type Url;
+        type MimeType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MimeType = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `mime_type` field to Set
-    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMimeType<St> {}
-    impl<St: State> State for SetMimeType<St> {
-        type MimeType = Set<members::mime_type>;
-        type Url = St::Url;
+        type MimeType = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type MimeType = St::MimeType;
         type Url = Set<members::url>;
+        type MimeType = St::MimeType;
+    }
+    ///State transition - sets the `mime_type` field to Set
+    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMimeType<St> {}
+    impl<St: State> State for SetMimeType<St> {
+        type Url = St::Url;
+        type MimeType = Set<members::mime_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `mime_type` field
-        pub struct mime_type(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `mime_type` field
+        pub struct mime_type(());
     }
 }
 
@@ -547,8 +547,8 @@ where
 impl<S: BosStr, St> ChaptersRefBuilder<S, St>
 where
     St: chapters_ref_state::State,
-    St::MimeType: chapters_ref_state::IsSet,
     St::Url: chapters_ref_state::IsSet,
+    St::MimeType: chapters_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ChaptersRef<S> {
@@ -920,127 +920,127 @@ pub mod episode_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Podcast;
         type Media;
-        type Duration;
-        type FeedItemGuid;
-        type CreatedAt;
+        type Podcast;
         type Title;
         type PublishedAt;
+        type FeedItemGuid;
+        type Duration;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Podcast = Unset;
         type Media = Unset;
-        type Duration = Unset;
-        type FeedItemGuid = Unset;
-        type CreatedAt = Unset;
+        type Podcast = Unset;
         type Title = Unset;
         type PublishedAt = Unset;
+        type FeedItemGuid = Unset;
+        type Duration = Unset;
+        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `media` field to Set
+    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMedia<St> {}
+    impl<St: State> State for SetMedia<St> {
+        type Media = Set<members::media>;
+        type Podcast = St::Podcast;
+        type Title = St::Title;
+        type PublishedAt = St::PublishedAt;
+        type FeedItemGuid = St::FeedItemGuid;
+        type Duration = St::Duration;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `podcast` field to Set
     pub struct SetPodcast<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPodcast<St> {}
     impl<St: State> State for SetPodcast<St> {
-        type Podcast = Set<members::podcast>;
         type Media = St::Media;
-        type Duration = St::Duration;
-        type FeedItemGuid = St::FeedItemGuid;
-        type CreatedAt = St::CreatedAt;
+        type Podcast = Set<members::podcast>;
         type Title = St::Title;
         type PublishedAt = St::PublishedAt;
+        type FeedItemGuid = St::FeedItemGuid;
+        type Duration = St::Duration;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `media` field to Set
-    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMedia<St> {}
-    impl<St: State> State for SetMedia<St> {
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Media = St::Media;
         type Podcast = St::Podcast;
-        type Media = Set<members::media>;
-        type Duration = St::Duration;
+        type Title = Set<members::title>;
+        type PublishedAt = St::PublishedAt;
         type FeedItemGuid = St::FeedItemGuid;
+        type Duration = St::Duration;
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-        type PublishedAt = St::PublishedAt;
     }
-    ///State transition - sets the `duration` field to Set
-    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDuration<St> {}
-    impl<St: State> State for SetDuration<St> {
-        type Podcast = St::Podcast;
+    ///State transition - sets the `published_at` field to Set
+    pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPublishedAt<St> {}
+    impl<St: State> State for SetPublishedAt<St> {
         type Media = St::Media;
-        type Duration = Set<members::duration>;
+        type Podcast = St::Podcast;
+        type Title = St::Title;
+        type PublishedAt = Set<members::published_at>;
         type FeedItemGuid = St::FeedItemGuid;
+        type Duration = St::Duration;
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-        type PublishedAt = St::PublishedAt;
     }
     ///State transition - sets the `feed_item_guid` field to Set
     pub struct SetFeedItemGuid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeedItemGuid<St> {}
     impl<St: State> State for SetFeedItemGuid<St> {
-        type Podcast = St::Podcast;
         type Media = St::Media;
-        type Duration = St::Duration;
+        type Podcast = St::Podcast;
+        type Title = St::Title;
+        type PublishedAt = St::PublishedAt;
         type FeedItemGuid = Set<members::feed_item_guid>;
+        type Duration = St::Duration;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `duration` field to Set
+    pub struct SetDuration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDuration<St> {}
+    impl<St: State> State for SetDuration<St> {
+        type Media = St::Media;
+        type Podcast = St::Podcast;
         type Title = St::Title;
         type PublishedAt = St::PublishedAt;
+        type FeedItemGuid = St::FeedItemGuid;
+        type Duration = Set<members::duration>;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Podcast = St::Podcast;
         type Media = St::Media;
-        type Duration = St::Duration;
-        type FeedItemGuid = St::FeedItemGuid;
-        type CreatedAt = Set<members::created_at>;
+        type Podcast = St::Podcast;
         type Title = St::Title;
         type PublishedAt = St::PublishedAt;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Podcast = St::Podcast;
-        type Media = St::Media;
-        type Duration = St::Duration;
         type FeedItemGuid = St::FeedItemGuid;
-        type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
-        type PublishedAt = St::PublishedAt;
-    }
-    ///State transition - sets the `published_at` field to Set
-    pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPublishedAt<St> {}
-    impl<St: State> State for SetPublishedAt<St> {
-        type Podcast = St::Podcast;
-        type Media = St::Media;
         type Duration = St::Duration;
-        type FeedItemGuid = St::FeedItemGuid;
-        type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
-        type PublishedAt = Set<members::published_at>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `podcast` field
-        pub struct podcast(());
         ///Marker type for the `media` field
         pub struct media(());
-        ///Marker type for the `duration` field
-        pub struct duration(());
-        ///Marker type for the `feed_item_guid` field
-        pub struct feed_item_guid(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `podcast` field
+        pub struct podcast(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `published_at` field
         pub struct published_at(());
+        ///Marker type for the `feed_item_guid` field
+        pub struct feed_item_guid(());
+        ///Marker type for the `duration` field
+        pub struct duration(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -1389,13 +1389,13 @@ impl<S: BosStr, St: episode_state::State> EpisodeBuilder<S, St> {
 impl<S: BosStr, St> EpisodeBuilder<S, St>
 where
     St: episode_state::State,
-    St::Podcast: episode_state::IsSet,
     St::Media: episode_state::IsSet,
-    St::Duration: episode_state::IsSet,
-    St::FeedItemGuid: episode_state::IsSet,
-    St::CreatedAt: episode_state::IsSet,
+    St::Podcast: episode_state::IsSet,
     St::Title: episode_state::IsSet,
     St::PublishedAt: episode_state::IsSet,
+    St::FeedItemGuid: episode_state::IsSet,
+    St::Duration: episode_state::IsSet,
+    St::CreatedAt: episode_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Episode<S> {
@@ -1455,37 +1455,37 @@ pub mod media_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MimeType;
         type Url;
+        type MimeType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MimeType = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `mime_type` field to Set
-    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMimeType<St> {}
-    impl<St: State> State for SetMimeType<St> {
-        type MimeType = Set<members::mime_type>;
-        type Url = St::Url;
+        type MimeType = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type MimeType = St::MimeType;
         type Url = Set<members::url>;
+        type MimeType = St::MimeType;
+    }
+    ///State transition - sets the `mime_type` field to Set
+    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMimeType<St> {}
+    impl<St: State> State for SetMimeType<St> {
+        type Url = St::Url;
+        type MimeType = Set<members::mime_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `mime_type` field
-        pub struct mime_type(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `mime_type` field
+        pub struct mime_type(());
     }
 }
 
@@ -1555,8 +1555,8 @@ where
 impl<S: BosStr, St> MediaRefBuilder<S, St>
 where
     St: media_ref_state::State,
-    St::MimeType: media_ref_state::IsSet,
     St::Url: media_ref_state::IsSet,
+    St::MimeType: media_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MediaRef<S> {
@@ -1586,37 +1586,37 @@ pub mod transcript_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Url;
         type MimeType;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Url = Unset;
         type MimeType = Unset;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Url = Set<members::url>;
-        type MimeType = St::MimeType;
+        type Url = Unset;
     }
     ///State transition - sets the `mime_type` field to Set
     pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMimeType<St> {}
     impl<St: State> State for SetMimeType<St> {
-        type Url = St::Url;
         type MimeType = Set<members::mime_type>;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type MimeType = St::MimeType;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `mime_type` field
         pub struct mime_type(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -1699,8 +1699,8 @@ where
 impl<S: BosStr, St> TranscriptRefBuilder<S, St>
 where
     St: transcript_ref_state::State,
-    St::Url: transcript_ref_state::IsSet,
     St::MimeType: transcript_ref_state::IsSet,
+    St::Url: transcript_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TranscriptRef<S> {
diff --git a/crates/jacquard-api/src/org_atpodcasting/follow.rs b/crates/jacquard-api/src/org_atpodcasting/follow.rs
index 6e82c00d..bb29f97d 100644
--- a/crates/jacquard-api/src/org_atpodcasting/follow.rs
+++ b/crates/jacquard-api/src/org_atpodcasting/follow.rs
@@ -115,37 +115,37 @@ pub mod follow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -215,8 +215,8 @@ where
 impl<S: BosStr, St> FollowBuilder<S, St>
 where
     St: follow_state::State,
-    St::CreatedAt: follow_state::IsSet,
     St::Subject: follow_state::IsSet,
+    St::CreatedAt: follow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Follow<S> {
diff --git a/crates/jacquard-api/src/org_atpodcasting/podcast.rs b/crates/jacquard-api/src/org_atpodcasting/podcast.rs
index 3fbb75c3..ee1fdce0 100644
--- a/crates/jacquard-api/src/org_atpodcasting/podcast.rs
+++ b/crates/jacquard-api/src/org_atpodcasting/podcast.rs
@@ -223,151 +223,151 @@ pub mod podcast_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
+        type Guid;
+        type Artwork;
         type Title;
         type FeedUrl;
-        type Categories;
-        type Artwork;
-        type Language;
         type Description;
-        type Guid;
-        type CreatedAt;
+        type Language;
+        type Categories;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
+        type Guid = Unset;
+        type Artwork = Unset;
         type Title = Unset;
         type FeedUrl = Unset;
-        type Categories = Unset;
-        type Artwork = Unset;
-        type Language = Unset;
         type Description = Unset;
-        type Guid = Unset;
-        type CreatedAt = Unset;
+        type Language = Unset;
+        type Categories = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type FeedUrl = St::FeedUrl;
-        type Categories = St::Categories;
-        type Artwork = St::Artwork;
-        type Language = St::Language;
-        type Description = St::Description;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `feed_url` field to Set
-    pub struct SetFeedUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFeedUrl<St> {}
-    impl<St: State> State for SetFeedUrl<St> {
-        type Title = St::Title;
-        type FeedUrl = Set<members::feed_url>;
-        type Categories = St::Categories;
         type Artwork = St::Artwork;
-        type Language = St::Language;
+        type Title = St::Title;
+        type FeedUrl = St::FeedUrl;
         type Description = St::Description;
-        type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
+        type Language = St::Language;
+        type Categories = St::Categories;
     }
-    ///State transition - sets the `categories` field to Set
-    pub struct SetCategories<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCategories<St> {}
-    impl<St: State> State for SetCategories<St> {
+    ///State transition - sets the `guid` field to Set
+    pub struct SetGuid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGuid<St> {}
+    impl<St: State> State for SetGuid<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = Set<members::guid>;
+        type Artwork = St::Artwork;
         type Title = St::Title;
         type FeedUrl = St::FeedUrl;
-        type Categories = Set<members::categories>;
-        type Artwork = St::Artwork;
-        type Language = St::Language;
         type Description = St::Description;
-        type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
+        type Language = St::Language;
+        type Categories = St::Categories;
     }
     ///State transition - sets the `artwork` field to Set
     pub struct SetArtwork<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetArtwork<St> {}
     impl<St: State> State for SetArtwork<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
+        type Artwork = Set<members::artwork>;
         type Title = St::Title;
         type FeedUrl = St::FeedUrl;
-        type Categories = St::Categories;
-        type Artwork = Set<members::artwork>;
-        type Language = St::Language;
         type Description = St::Description;
-        type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
+        type Language = St::Language;
+        type Categories = St::Categories;
     }
-    ///State transition - sets the `language` field to Set
-    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLanguage<St> {}
-    impl<St: State> State for SetLanguage<St> {
-        type Title = St::Title;
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
+        type Artwork = St::Artwork;
+        type Title = Set<members::title>;
         type FeedUrl = St::FeedUrl;
+        type Description = St::Description;
+        type Language = St::Language;
         type Categories = St::Categories;
+    }
+    ///State transition - sets the `feed_url` field to Set
+    pub struct SetFeedUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFeedUrl<St> {}
+    impl<St: State> State for SetFeedUrl<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
         type Artwork = St::Artwork;
-        type Language = Set<members::language>;
+        type Title = St::Title;
+        type FeedUrl = Set<members::feed_url>;
         type Description = St::Description;
-        type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
+        type Language = St::Language;
+        type Categories = St::Categories;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
+        type Artwork = St::Artwork;
         type Title = St::Title;
         type FeedUrl = St::FeedUrl;
-        type Categories = St::Categories;
-        type Artwork = St::Artwork;
-        type Language = St::Language;
         type Description = Set<members::description>;
-        type Guid = St::Guid;
-        type CreatedAt = St::CreatedAt;
+        type Language = St::Language;
+        type Categories = St::Categories;
     }
-    ///State transition - sets the `guid` field to Set
-    pub struct SetGuid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGuid<St> {}
-    impl<St: State> State for SetGuid<St> {
+    ///State transition - sets the `language` field to Set
+    pub struct SetLanguage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLanguage<St> {}
+    impl<St: State> State for SetLanguage<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
+        type Artwork = St::Artwork;
         type Title = St::Title;
         type FeedUrl = St::FeedUrl;
-        type Categories = St::Categories;
-        type Artwork = St::Artwork;
-        type Language = St::Language;
         type Description = St::Description;
-        type Guid = Set<members::guid>;
-        type CreatedAt = St::CreatedAt;
+        type Language = Set<members::language>;
+        type Categories = St::Categories;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `categories` field to Set
+    pub struct SetCategories<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCategories<St> {}
+    impl<St: State> State for SetCategories<St> {
+        type CreatedAt = St::CreatedAt;
+        type Guid = St::Guid;
+        type Artwork = St::Artwork;
         type Title = St::Title;
         type FeedUrl = St::FeedUrl;
-        type Categories = St::Categories;
-        type Artwork = St::Artwork;
-        type Language = St::Language;
         type Description = St::Description;
-        type Guid = St::Guid;
-        type CreatedAt = Set<members::created_at>;
+        type Language = St::Language;
+        type Categories = Set<members::categories>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `guid` field
+        pub struct guid(());
+        ///Marker type for the `artwork` field
+        pub struct artwork(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `feed_url` field
         pub struct feed_url(());
-        ///Marker type for the `categories` field
-        pub struct categories(());
-        ///Marker type for the `artwork` field
-        pub struct artwork(());
-        ///Marker type for the `language` field
-        pub struct language(());
         ///Marker type for the `description` field
         pub struct description(());
-        ///Marker type for the `guid` field
-        pub struct guid(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `language` field
+        pub struct language(());
+        ///Marker type for the `categories` field
+        pub struct categories(());
     }
 }
 
@@ -602,14 +602,14 @@ where
 impl<S: BosStr, St> PodcastBuilder<S, St>
 where
     St: podcast_state::State,
+    St::CreatedAt: podcast_state::IsSet,
+    St::Guid: podcast_state::IsSet,
+    St::Artwork: podcast_state::IsSet,
     St::Title: podcast_state::IsSet,
     St::FeedUrl: podcast_state::IsSet,
-    St::Categories: podcast_state::IsSet,
-    St::Artwork: podcast_state::IsSet,
-    St::Language: podcast_state::IsSet,
     St::Description: podcast_state::IsSet,
-    St::Guid: podcast_state::IsSet,
-    St::CreatedAt: podcast_state::IsSet,
+    St::Language: podcast_state::IsSet,
+    St::Categories: podcast_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Podcast<S> {
diff --git a/crates/jacquard-api/src/org_atsui/clip.rs b/crates/jacquard-api/src/org_atsui/clip.rs
index d3b94569..12dfa265 100644
--- a/crates/jacquard-api/src/org_atsui/clip.rs
+++ b/crates/jacquard-api/src/org_atsui/clip.rs
@@ -133,37 +133,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Height;
         type Width;
+        type Height;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Height = Unset;
         type Width = Unset;
-    }
-    ///State transition - sets the `height` field to Set
-    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHeight<St> {}
-    impl<St: State> State for SetHeight<St> {
-        type Height = Set<members::height>;
-        type Width = St::Width;
+        type Height = Unset;
     }
     ///State transition - sets the `width` field to Set
     pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidth<St> {}
     impl<St: State> State for SetWidth<St> {
-        type Height = St::Height;
         type Width = Set<members::width>;
+        type Height = St::Height;
+    }
+    ///State transition - sets the `height` field to Set
+    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHeight<St> {}
+    impl<St: State> State for SetHeight<St> {
+        type Width = St::Width;
+        type Height = Set<members::height>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `height` field
-        pub struct height(());
         ///Marker type for the `width` field
         pub struct width(());
+        ///Marker type for the `height` field
+        pub struct height(());
     }
 }
 
@@ -233,8 +233,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Height: aspect_ratio_state::IsSet,
     St::Width: aspect_ratio_state::IsSet,
+    St::Height: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
diff --git a/crates/jacquard-api/src/org_devcon/event/test.rs b/crates/jacquard-api/src/org_devcon/event/test.rs
index 73c96bc7..4cd0035e 100644
--- a/crates/jacquard-api/src/org_devcon/event/test.rs
+++ b/crates/jacquard-api/src/org_devcon/event/test.rs
@@ -126,49 +126,49 @@ pub mod test_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Start;
+        type Title;
         type End;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Start = Unset;
+        type Title = Unset;
         type End = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Start = St::Start;
-        type End = St::End;
-    }
     ///State transition - sets the `start` field to Set
     pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStart<St> {}
     impl<St: State> State for SetStart<St> {
-        type Title = St::Title;
         type Start = Set<members::start>;
+        type Title = St::Title;
+        type End = St::End;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Start = St::Start;
+        type Title = Set<members::title>;
         type End = St::End;
     }
     ///State transition - sets the `end` field to Set
     pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEnd<St> {}
     impl<St: State> State for SetEnd<St> {
-        type Title = St::Title;
         type Start = St::Start;
+        type Title = St::Title;
         type End = Set<members::end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `start` field
         pub struct start(());
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `end` field
         pub struct end(());
     }
@@ -319,8 +319,8 @@ impl<S: BosStr, St: test_state::State> TestBuilder<S, St> {
 impl<S: BosStr, St> TestBuilder<S, St>
 where
     St: test_state::State,
-    St::Title: test_state::IsSet,
     St::Start: test_state::IsSet,
+    St::Title: test_state::IsSet,
     St::End: test_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/org_farmapps/temp/agroconnect/cl022.rs b/crates/jacquard-api/src/org_farmapps/temp/agroconnect/cl022.rs
index 50b97899..d0e11ae9 100644
--- a/crates/jacquard-api/src/org_farmapps/temp/agroconnect/cl022.rs
+++ b/crates/jacquard-api/src/org_farmapps/temp/agroconnect/cl022.rs
@@ -178,37 +178,37 @@ pub mod cl022_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Description;
         type Id;
+        type Description;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Description = Unset;
         type Id = Unset;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Description = Set<members::description>;
-        type Id = St::Id;
+        type Description = Unset;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Description = St::Description;
         type Id = Set<members::id>;
+        type Description = St::Description;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Id = St::Id;
+        type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `id` field
         pub struct id(());
+        ///Marker type for the `description` field
+        pub struct description(());
     }
 }
 
@@ -407,8 +407,8 @@ impl<S: BosStr, St: cl022_state::State> Cl022Builder<S, St> {
 impl<S: BosStr, St> Cl022Builder<S, St>
 where
     St: cl022_state::State,
-    St::Description: cl022_state::IsSet,
     St::Id: cl022_state::IsSet,
+    St::Description: cl022_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Cl022<S> {
diff --git a/crates/jacquard-api/src/org_farmapps/temp/ecrop.rs b/crates/jacquard-api/src/org_farmapps/temp/ecrop.rs
index 2510b486..a5c62782 100644
--- a/crates/jacquard-api/src/org_farmapps/temp/ecrop.rs
+++ b/crates/jacquard-api/src/org_farmapps/temp/ecrop.rs
@@ -61,37 +61,37 @@ pub mod code_type_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Code;
         type ListId;
+        type Code;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Code = Unset;
         type ListId = Unset;
-    }
-    ///State transition - sets the `code` field to Set
-    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCode<St> {}
-    impl<St: State> State for SetCode<St> {
-        type Code = Set<members::code>;
-        type ListId = St::ListId;
+        type Code = Unset;
     }
     ///State transition - sets the `list_id` field to Set
     pub struct SetListId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetListId<St> {}
     impl<St: State> State for SetListId<St> {
-        type Code = St::Code;
         type ListId = Set<members::list_id>;
+        type Code = St::Code;
+    }
+    ///State transition - sets the `code` field to Set
+    pub struct SetCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCode<St> {}
+    impl<St: State> State for SetCode<St> {
+        type ListId = St::ListId;
+        type Code = Set<members::code>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `code` field
-        pub struct code(());
         ///Marker type for the `list_id` field
         pub struct list_id(());
+        ///Marker type for the `code` field
+        pub struct code(());
     }
 }
 
@@ -161,8 +161,8 @@ where
 impl<S: BosStr, St> CodeTypeBuilder<S, St>
 where
     St: code_type_state::State,
-    St::Code: code_type_state::IsSet,
     St::ListId: code_type_state::IsSet,
+    St::Code: code_type_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CodeType<S> {
diff --git a/crates/jacquard-api/src/org_hyperboards/board.rs b/crates/jacquard-api/src/org_hyperboards/board.rs
index 3480ca03..140b9ac5 100644
--- a/crates/jacquard-api/src/org_hyperboards/board.rs
+++ b/crates/jacquard-api/src/org_hyperboards/board.rs
@@ -1204,37 +1204,37 @@ pub mod board_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -1341,8 +1341,8 @@ where
 impl<S: BosStr, St> BoardBuilder<S, St>
 where
     St: board_state::State,
-    St::CreatedAt: board_state::IsSet,
     St::Subject: board_state::IsSet,
+    St::CreatedAt: board_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Board<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/claim/activity.rs b/crates/jacquard-api/src/org_hypercerts/claim/activity.rs
index c5b2b88b..e448fef2 100644
--- a/crates/jacquard-api/src/org_hypercerts/claim/activity.rs
+++ b/crates/jacquard-api/src/org_hypercerts/claim/activity.rs
@@ -909,51 +909,51 @@ pub mod activity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ShortDescription;
-        type Title;
         type CreatedAt;
+        type Title;
+        type ShortDescription;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ShortDescription = Unset;
-        type Title = Unset;
         type CreatedAt = Unset;
+        type Title = Unset;
+        type ShortDescription = Unset;
     }
-    ///State transition - sets the `short_description` field to Set
-    pub struct SetShortDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetShortDescription<St> {}
-    impl<St: State> State for SetShortDescription<St> {
-        type ShortDescription = Set<members::short_description>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
+        type ShortDescription = St::ShortDescription;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type ShortDescription = St::ShortDescription;
-        type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Title = Set<members::title>;
         type ShortDescription = St::ShortDescription;
+    }
+    ///State transition - sets the `short_description` field to Set
+    pub struct SetShortDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetShortDescription<St> {}
+    impl<St: State> State for SetShortDescription<St> {
+        type CreatedAt = St::CreatedAt;
         type Title = St::Title;
-        type CreatedAt = Set<members::created_at>;
+        type ShortDescription = Set<members::short_description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `short_description` field
-        pub struct short_description(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `short_description` field
+        pub struct short_description(());
     }
 }
 
@@ -1197,9 +1197,9 @@ impl<S: BosStr, St: activity_state::State> ActivityBuilder<S, St> {
 impl<S: BosStr, St> ActivityBuilder<S, St>
 where
     St: activity_state::State,
-    St::ShortDescription: activity_state::IsSet,
-    St::Title: activity_state::IsSet,
     St::CreatedAt: activity_state::IsSet,
+    St::Title: activity_state::IsSet,
+    St::ShortDescription: activity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Activity<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/claim/rights.rs b/crates/jacquard-api/src/org_hypercerts/claim/rights.rs
index 0a04c066..168a9798 100644
--- a/crates/jacquard-api/src/org_hypercerts/claim/rights.rs
+++ b/crates/jacquard-api/src/org_hypercerts/claim/rights.rs
@@ -180,67 +180,67 @@ pub mod rights_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type RightsName;
+        type RightsType;
         type RightsDescription;
         type CreatedAt;
-        type RightsType;
-        type RightsName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type RightsName = Unset;
+        type RightsType = Unset;
         type RightsDescription = Unset;
         type CreatedAt = Unset;
-        type RightsType = Unset;
-        type RightsName = Unset;
+    }
+    ///State transition - sets the `rights_name` field to Set
+    pub struct SetRightsName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRightsName<St> {}
+    impl<St: State> State for SetRightsName<St> {
+        type RightsName = Set<members::rights_name>;
+        type RightsType = St::RightsType;
+        type RightsDescription = St::RightsDescription;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `rights_type` field to Set
+    pub struct SetRightsType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRightsType<St> {}
+    impl<St: State> State for SetRightsType<St> {
+        type RightsName = St::RightsName;
+        type RightsType = Set<members::rights_type>;
+        type RightsDescription = St::RightsDescription;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `rights_description` field to Set
     pub struct SetRightsDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRightsDescription<St> {}
     impl<St: State> State for SetRightsDescription<St> {
+        type RightsName = St::RightsName;
+        type RightsType = St::RightsType;
         type RightsDescription = Set<members::rights_description>;
         type CreatedAt = St::CreatedAt;
-        type RightsType = St::RightsType;
-        type RightsName = St::RightsName;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type RightsDescription = St::RightsDescription;
-        type CreatedAt = Set<members::created_at>;
-        type RightsType = St::RightsType;
-        type RightsName = St::RightsName;
-    }
-    ///State transition - sets the `rights_type` field to Set
-    pub struct SetRightsType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRightsType<St> {}
-    impl<St: State> State for SetRightsType<St> {
-        type RightsDescription = St::RightsDescription;
-        type CreatedAt = St::CreatedAt;
-        type RightsType = Set<members::rights_type>;
         type RightsName = St::RightsName;
-    }
-    ///State transition - sets the `rights_name` field to Set
-    pub struct SetRightsName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRightsName<St> {}
-    impl<St: State> State for SetRightsName<St> {
-        type RightsDescription = St::RightsDescription;
-        type CreatedAt = St::CreatedAt;
         type RightsType = St::RightsType;
-        type RightsName = Set<members::rights_name>;
+        type RightsDescription = St::RightsDescription;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `rights_name` field
+        pub struct rights_name(());
+        ///Marker type for the `rights_type` field
+        pub struct rights_type(());
         ///Marker type for the `rights_description` field
         pub struct rights_description(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `rights_type` field
-        pub struct rights_type(());
-        ///Marker type for the `rights_name` field
-        pub struct rights_name(());
     }
 }
 
@@ -367,10 +367,10 @@ where
 impl<S: BosStr, St> RightsBuilder<S, St>
 where
     St: rights_state::State,
+    St::RightsName: rights_state::IsSet,
+    St::RightsType: rights_state::IsSet,
     St::RightsDescription: rights_state::IsSet,
     St::CreatedAt: rights_state::IsSet,
-    St::RightsType: rights_state::IsSet,
-    St::RightsName: rights_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rights<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/collection.rs b/crates/jacquard-api/src/org_hypercerts/collection.rs
index 92242bda..5c6c1fbe 100644
--- a/crates/jacquard-api/src/org_hypercerts/collection.rs
+++ b/crates/jacquard-api/src/org_hypercerts/collection.rs
@@ -564,37 +564,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Title;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = Set<members::title>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -765,8 +765,8 @@ impl<S: BosStr, St: collection_state::State> CollectionBuilder<S, St> {
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::CreatedAt: collection_state::IsSet,
     St::Title: collection_state::IsSet,
+    St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/context/acknowledgement.rs b/crates/jacquard-api/src/org_hypercerts/context/acknowledgement.rs
index b257f3a4..cc73a9ee 100644
--- a/crates/jacquard-api/src/org_hypercerts/context/acknowledgement.rs
+++ b/crates/jacquard-api/src/org_hypercerts/context/acknowledgement.rs
@@ -157,51 +157,51 @@ pub mod acknowledgement_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Acknowledged;
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
+        type Acknowledged;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Acknowledged = Unset;
-        type CreatedAt = Unset;
         type Subject = Unset;
+        type CreatedAt = Unset;
+        type Acknowledged = Unset;
     }
-    ///State transition - sets the `acknowledged` field to Set
-    pub struct SetAcknowledged<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAcknowledged<St> {}
-    impl<St: State> State for SetAcknowledged<St> {
-        type Acknowledged = Set<members::acknowledged>;
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
+        type Acknowledged = St::Acknowledged;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Acknowledged = St::Acknowledged;
-        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = Set<members::created_at>;
         type Acknowledged = St::Acknowledged;
+    }
+    ///State transition - sets the `acknowledged` field to Set
+    pub struct SetAcknowledged<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAcknowledged<St> {}
+    impl<St: State> State for SetAcknowledged<St> {
+        type Subject = St::Subject;
         type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type Acknowledged = Set<members::acknowledged>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `acknowledged` field
-        pub struct acknowledged(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `acknowledged` field
+        pub struct acknowledged(());
     }
 }
 
@@ -325,9 +325,9 @@ where
 impl<S: BosStr, St> AcknowledgementBuilder<S, St>
 where
     St: acknowledgement_state::State,
-    St::Acknowledged: acknowledgement_state::IsSet,
-    St::CreatedAt: acknowledgement_state::IsSet,
     St::Subject: acknowledgement_state::IsSet,
+    St::CreatedAt: acknowledgement_state::IsSet,
+    St::Acknowledged: acknowledgement_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Acknowledgement<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/context/evaluation.rs b/crates/jacquard-api/src/org_hypercerts/context/evaluation.rs
index 32b7d391..5574429a 100644
--- a/crates/jacquard-api/src/org_hypercerts/context/evaluation.rs
+++ b/crates/jacquard-api/src/org_hypercerts/context/evaluation.rs
@@ -668,51 +668,51 @@ pub mod score_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Max;
         type Value;
         type Min;
+        type Max;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Max = Unset;
         type Value = Unset;
         type Min = Unset;
-    }
-    ///State transition - sets the `max` field to Set
-    pub struct SetMax<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMax<St> {}
-    impl<St: State> State for SetMax<St> {
-        type Max = Set<members::max>;
-        type Value = St::Value;
-        type Min = St::Min;
+        type Max = Unset;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Max = St::Max;
         type Value = Set<members::value>;
         type Min = St::Min;
+        type Max = St::Max;
     }
     ///State transition - sets the `min` field to Set
     pub struct SetMin<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMin<St> {}
     impl<St: State> State for SetMin<St> {
-        type Max = St::Max;
         type Value = St::Value;
         type Min = Set<members::min>;
+        type Max = St::Max;
+    }
+    ///State transition - sets the `max` field to Set
+    pub struct SetMax<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMax<St> {}
+    impl<St: State> State for SetMax<St> {
+        type Value = St::Value;
+        type Min = St::Min;
+        type Max = Set<members::max>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `max` field
-        pub struct max(());
         ///Marker type for the `value` field
         pub struct value(());
         ///Marker type for the `min` field
         pub struct min(());
+        ///Marker type for the `max` field
+        pub struct max(());
     }
 }
 
@@ -801,9 +801,9 @@ where
 impl<S: BosStr, St> ScoreBuilder<S, St>
 where
     St: score_state::State,
-    St::Max: score_state::IsSet,
     St::Value: score_state::IsSet,
     St::Min: score_state::IsSet,
+    St::Max: score_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Score<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/context/measurement.rs b/crates/jacquard-api/src/org_hypercerts/context/measurement.rs
index 44cd23ef..1675e0cd 100644
--- a/crates/jacquard-api/src/org_hypercerts/context/measurement.rs
+++ b/crates/jacquard-api/src/org_hypercerts/context/measurement.rs
@@ -257,8 +257,8 @@ pub mod measurement_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Unit;
-        type CreatedAt;
         type Metric;
+        type CreatedAt;
         type Value;
     }
     /// Empty state - all required fields are unset
@@ -266,8 +266,8 @@ pub mod measurement_state {
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Unit = Unset;
-        type CreatedAt = Unset;
         type Metric = Unset;
+        type CreatedAt = Unset;
         type Value = Unset;
     }
     ///State transition - sets the `unit` field to Set
@@ -275,17 +275,8 @@ pub mod measurement_state {
     impl<St: State> sealed::Sealed for SetUnit<St> {}
     impl<St: State> State for SetUnit<St> {
         type Unit = Set<members::unit>;
-        type CreatedAt = St::CreatedAt;
-        type Metric = St::Metric;
-        type Value = St::Value;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Unit = St::Unit;
-        type CreatedAt = Set<members::created_at>;
         type Metric = St::Metric;
+        type CreatedAt = St::CreatedAt;
         type Value = St::Value;
     }
     ///State transition - sets the `metric` field to Set
@@ -293,8 +284,17 @@ pub mod measurement_state {
     impl<St: State> sealed::Sealed for SetMetric<St> {}
     impl<St: State> State for SetMetric<St> {
         type Unit = St::Unit;
-        type CreatedAt = St::CreatedAt;
         type Metric = Set<members::metric>;
+        type CreatedAt = St::CreatedAt;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Unit = St::Unit;
+        type Metric = St::Metric;
+        type CreatedAt = Set<members::created_at>;
         type Value = St::Value;
     }
     ///State transition - sets the `value` field to Set
@@ -302,8 +302,8 @@ pub mod measurement_state {
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
         type Unit = St::Unit;
-        type CreatedAt = St::CreatedAt;
         type Metric = St::Metric;
+        type CreatedAt = St::CreatedAt;
         type Value = Set<members::value>;
     }
     /// Marker types for field names
@@ -311,10 +311,10 @@ pub mod measurement_state {
     pub mod members {
         ///Marker type for the `unit` field
         pub struct unit(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `metric` field
         pub struct metric(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `value` field
         pub struct value(());
     }
@@ -585,8 +585,8 @@ impl<S: BosStr, St> MeasurementBuilder<S, St>
 where
     St: measurement_state::State,
     St::Unit: measurement_state::IsSet,
-    St::CreatedAt: measurement_state::IsSet,
     St::Metric: measurement_state::IsSet,
+    St::CreatedAt: measurement_state::IsSet,
     St::Value: measurement_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/org_hypercerts/funding/receipt.rs b/crates/jacquard-api/src/org_hypercerts/funding/receipt.rs
index 262d098b..5f9ed48b 100644
--- a/crates/jacquard-api/src/org_hypercerts/funding/receipt.rs
+++ b/crates/jacquard-api/src/org_hypercerts/funding/receipt.rs
@@ -212,85 +212,85 @@ pub mod receipt_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type To;
-        type Amount;
         type From;
         type Currency;
+        type To;
         type CreatedAt;
+        type Amount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type To = Unset;
-        type Amount = Unset;
         type From = Unset;
         type Currency = Unset;
+        type To = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `to` field to Set
-    pub struct SetTo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTo<St> {}
-    impl<St: State> State for SetTo<St> {
-        type To = Set<members::to>;
-        type Amount = St::Amount;
-        type From = St::From;
-        type Currency = St::Currency;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `amount` field to Set
-    pub struct SetAmount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAmount<St> {}
-    impl<St: State> State for SetAmount<St> {
-        type To = St::To;
-        type Amount = Set<members::amount>;
-        type From = St::From;
-        type Currency = St::Currency;
-        type CreatedAt = St::CreatedAt;
+        type Amount = Unset;
     }
     ///State transition - sets the `from` field to Set
     pub struct SetFrom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFrom<St> {}
     impl<St: State> State for SetFrom<St> {
-        type To = St::To;
-        type Amount = St::Amount;
         type From = Set<members::from>;
         type Currency = St::Currency;
+        type To = St::To;
         type CreatedAt = St::CreatedAt;
+        type Amount = St::Amount;
     }
     ///State transition - sets the `currency` field to Set
     pub struct SetCurrency<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCurrency<St> {}
     impl<St: State> State for SetCurrency<St> {
+        type From = St::From;
+        type Currency = Set<members::currency>;
         type To = St::To;
+        type CreatedAt = St::CreatedAt;
         type Amount = St::Amount;
+    }
+    ///State transition - sets the `to` field to Set
+    pub struct SetTo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTo<St> {}
+    impl<St: State> State for SetTo<St> {
         type From = St::From;
-        type Currency = Set<members::currency>;
+        type Currency = St::Currency;
+        type To = Set<members::to>;
         type CreatedAt = St::CreatedAt;
+        type Amount = St::Amount;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type From = St::From;
+        type Currency = St::Currency;
         type To = St::To;
+        type CreatedAt = Set<members::created_at>;
         type Amount = St::Amount;
+    }
+    ///State transition - sets the `amount` field to Set
+    pub struct SetAmount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAmount<St> {}
+    impl<St: State> State for SetAmount<St> {
         type From = St::From;
         type Currency = St::Currency;
-        type CreatedAt = Set<members::created_at>;
+        type To = St::To;
+        type CreatedAt = St::CreatedAt;
+        type Amount = Set<members::amount>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `to` field
-        pub struct to(());
-        ///Marker type for the `amount` field
-        pub struct amount(());
         ///Marker type for the `from` field
         pub struct from(());
         ///Marker type for the `currency` field
         pub struct currency(());
+        ///Marker type for the `to` field
+        pub struct to(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `amount` field
+        pub struct amount(());
     }
 }
 
@@ -507,11 +507,11 @@ impl<S: BosStr, St: receipt_state::State> ReceiptBuilder<S, St> {
 impl<S: BosStr, St> ReceiptBuilder<S, St>
 where
     St: receipt_state::State,
-    St::To: receipt_state::IsSet,
-    St::Amount: receipt_state::IsSet,
     St::From: receipt_state::IsSet,
     St::Currency: receipt_state::IsSet,
+    St::To: receipt_state::IsSet,
     St::CreatedAt: receipt_state::IsSet,
+    St::Amount: receipt_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Receipt<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/helper/work_scope_tag.rs b/crates/jacquard-api/src/org_hypercerts/helper/work_scope_tag.rs
index d66b6362..bee2fad4 100644
--- a/crates/jacquard-api/src/org_hypercerts/helper/work_scope_tag.rs
+++ b/crates/jacquard-api/src/org_hypercerts/helper/work_scope_tag.rs
@@ -210,50 +210,50 @@ pub mod work_scope_tag_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Key;
-        type CreatedAt;
         type Label;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Key = Unset;
-        type CreatedAt = Unset;
         type Label = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
         type Key = Set<members::key>;
-        type CreatedAt = St::CreatedAt;
-        type Label = St::Label;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Key = St::Key;
-        type CreatedAt = Set<members::created_at>;
         type Label = St::Label;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `label` field to Set
     pub struct SetLabel<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLabel<St> {}
     impl<St: State> State for SetLabel<St> {
         type Key = St::Key;
-        type CreatedAt = St::CreatedAt;
         type Label = Set<members::label>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Key = St::Key;
+        type Label = St::Label;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `key` field
         pub struct key(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `label` field
         pub struct label(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -423,8 +423,8 @@ impl<S: BosStr, St> WorkScopeTagBuilder<S, St>
 where
     St: work_scope_tag_state::State,
     St::Key: work_scope_tag_state::IsSet,
-    St::CreatedAt: work_scope_tag_state::IsSet,
     St::Label: work_scope_tag_state::IsSet,
+    St::CreatedAt: work_scope_tag_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WorkScopeTag<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/workscope/cel.rs b/crates/jacquard-api/src/org_hypercerts/workscope/cel.rs
index 8babb0e2..4b52fb48 100644
--- a/crates/jacquard-api/src/org_hypercerts/workscope/cel.rs
+++ b/crates/jacquard-api/src/org_hypercerts/workscope/cel.rs
@@ -190,8 +190,8 @@ pub mod cel_state {
     pub trait State: sealed::Sealed {
         type Version;
         type Expression;
-        type CreatedAt;
         type UsedTags;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -199,8 +199,8 @@ pub mod cel_state {
     impl State for Empty {
         type Version = Unset;
         type Expression = Unset;
-        type CreatedAt = Unset;
         type UsedTags = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `version` field to Set
     pub struct SetVersion<St: State = Empty>(PhantomData<fn() -> St>);
@@ -208,8 +208,8 @@ pub mod cel_state {
     impl<St: State> State for SetVersion<St> {
         type Version = Set<members::version>;
         type Expression = St::Expression;
-        type CreatedAt = St::CreatedAt;
         type UsedTags = St::UsedTags;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `expression` field to Set
     pub struct SetExpression<St: State = Empty>(PhantomData<fn() -> St>);
@@ -217,17 +217,8 @@ pub mod cel_state {
     impl<St: State> State for SetExpression<St> {
         type Version = St::Version;
         type Expression = Set<members::expression>;
-        type CreatedAt = St::CreatedAt;
-        type UsedTags = St::UsedTags;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Version = St::Version;
-        type Expression = St::Expression;
-        type CreatedAt = Set<members::created_at>;
         type UsedTags = St::UsedTags;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `used_tags` field to Set
     pub struct SetUsedTags<St: State = Empty>(PhantomData<fn() -> St>);
@@ -235,8 +226,17 @@ pub mod cel_state {
     impl<St: State> State for SetUsedTags<St> {
         type Version = St::Version;
         type Expression = St::Expression;
-        type CreatedAt = St::CreatedAt;
         type UsedTags = Set<members::used_tags>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Version = St::Version;
+        type Expression = St::Expression;
+        type UsedTags = St::UsedTags;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -245,10 +245,10 @@ pub mod cel_state {
         pub struct version(());
         ///Marker type for the `expression` field
         pub struct expression(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `used_tags` field
         pub struct used_tags(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -363,8 +363,8 @@ where
     St: cel_state::State,
     St::Version: cel_state::IsSet,
     St::Expression: cel_state::IsSet,
-    St::CreatedAt: cel_state::IsSet,
     St::UsedTags: cel_state::IsSet,
+    St::CreatedAt: cel_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Cel<S> {
diff --git a/crates/jacquard-api/src/org_hypercerts/workscope/tag.rs b/crates/jacquard-api/src/org_hypercerts/workscope/tag.rs
index 43c2bd7f..4a07106d 100644
--- a/crates/jacquard-api/src/org_hypercerts/workscope/tag.rs
+++ b/crates/jacquard-api/src/org_hypercerts/workscope/tag.rs
@@ -408,49 +408,49 @@ pub mod tag_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Key;
         type Name;
+        type Key;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Key = Unset;
         type Name = Unset;
+        type Key = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `key` field to Set
-    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKey<St> {}
-    impl<St: State> State for SetKey<St> {
-        type Key = Set<members::key>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Key = St::Key;
         type Name = Set<members::name>;
+        type Key = St::Key;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `key` field to Set
+    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKey<St> {}
+    impl<St: State> State for SetKey<St> {
+        type Name = St::Name;
+        type Key = Set<members::key>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Key = St::Key;
         type Name = St::Name;
+        type Key = St::Key;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `key` field
-        pub struct key(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `key` field
+        pub struct key(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -657,8 +657,8 @@ impl<S: BosStr, St: tag_state::State> TagBuilder<S, St> {
 impl<S: BosStr, St> TagBuilder<S, St>
 where
     St: tag_state::State,
-    St::Key: tag_state::IsSet,
     St::Name: tag_state::IsSet,
+    St::Key: tag_state::IsSet,
     St::CreatedAt: tag_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/org_impactindexer/link/attestation.rs b/crates/jacquard-api/src/org_impactindexer/link/attestation.rs
index ceb963d6..e5750309 100644
--- a/crates/jacquard-api/src/org_impactindexer/link/attestation.rs
+++ b/crates/jacquard-api/src/org_impactindexer/link/attestation.rs
@@ -566,105 +566,105 @@ pub mod attestation_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Address;
+        type CreatedAt;
         type Message;
-        type ChainId;
         type SignatureType;
+        type ChainId;
         type Signature;
-        type CreatedAt;
-        type Address;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Address = Unset;
+        type CreatedAt = Unset;
         type Message = Unset;
-        type ChainId = Unset;
         type SignatureType = Unset;
+        type ChainId = Unset;
         type Signature = Unset;
-        type CreatedAt = Unset;
-        type Address = Unset;
     }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
-        type Message = Set<members::message>;
-        type ChainId = St::ChainId;
+    ///State transition - sets the `address` field to Set
+    pub struct SetAddress<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddress<St> {}
+    impl<St: State> State for SetAddress<St> {
+        type Address = Set<members::address>;
+        type CreatedAt = St::CreatedAt;
+        type Message = St::Message;
         type SignatureType = St::SignatureType;
+        type ChainId = St::ChainId;
         type Signature = St::Signature;
-        type CreatedAt = St::CreatedAt;
-        type Address = St::Address;
     }
-    ///State transition - sets the `chain_id` field to Set
-    pub struct SetChainId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChainId<St> {}
-    impl<St: State> State for SetChainId<St> {
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Address = St::Address;
+        type CreatedAt = Set<members::created_at>;
         type Message = St::Message;
-        type ChainId = Set<members::chain_id>;
         type SignatureType = St::SignatureType;
+        type ChainId = St::ChainId;
         type Signature = St::Signature;
-        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
         type Address = St::Address;
+        type CreatedAt = St::CreatedAt;
+        type Message = Set<members::message>;
+        type SignatureType = St::SignatureType;
+        type ChainId = St::ChainId;
+        type Signature = St::Signature;
     }
     ///State transition - sets the `signature_type` field to Set
     pub struct SetSignatureType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignatureType<St> {}
     impl<St: State> State for SetSignatureType<St> {
+        type Address = St::Address;
+        type CreatedAt = St::CreatedAt;
         type Message = St::Message;
-        type ChainId = St::ChainId;
         type SignatureType = Set<members::signature_type>;
+        type ChainId = St::ChainId;
         type Signature = St::Signature;
-        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `chain_id` field to Set
+    pub struct SetChainId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChainId<St> {}
+    impl<St: State> State for SetChainId<St> {
         type Address = St::Address;
+        type CreatedAt = St::CreatedAt;
+        type Message = St::Message;
+        type SignatureType = St::SignatureType;
+        type ChainId = Set<members::chain_id>;
+        type Signature = St::Signature;
     }
     ///State transition - sets the `signature` field to Set
     pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSignature<St> {}
     impl<St: State> State for SetSignature<St> {
-        type Message = St::Message;
-        type ChainId = St::ChainId;
-        type SignatureType = St::SignatureType;
-        type Signature = Set<members::signature>;
-        type CreatedAt = St::CreatedAt;
         type Address = St::Address;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = St::CreatedAt;
         type Message = St::Message;
-        type ChainId = St::ChainId;
         type SignatureType = St::SignatureType;
-        type Signature = St::Signature;
-        type CreatedAt = Set<members::created_at>;
-        type Address = St::Address;
-    }
-    ///State transition - sets the `address` field to Set
-    pub struct SetAddress<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddress<St> {}
-    impl<St: State> State for SetAddress<St> {
-        type Message = St::Message;
         type ChainId = St::ChainId;
-        type SignatureType = St::SignatureType;
-        type Signature = St::Signature;
-        type CreatedAt = St::CreatedAt;
-        type Address = Set<members::address>;
+        type Signature = Set<members::signature>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `address` field
+        pub struct address(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `message` field
         pub struct message(());
-        ///Marker type for the `chain_id` field
-        pub struct chain_id(());
         ///Marker type for the `signature_type` field
         pub struct signature_type(());
+        ///Marker type for the `chain_id` field
+        pub struct chain_id(());
         ///Marker type for the `signature` field
         pub struct signature(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `address` field
-        pub struct address(());
     }
 }
 
@@ -817,12 +817,12 @@ where
 impl<S: BosStr, St> AttestationBuilder<S, St>
 where
     St: attestation_state::State,
+    St::Address: attestation_state::IsSet,
+    St::CreatedAt: attestation_state::IsSet,
     St::Message: attestation_state::IsSet,
-    St::ChainId: attestation_state::IsSet,
     St::SignatureType: attestation_state::IsSet,
+    St::ChainId: attestation_state::IsSet,
     St::Signature: attestation_state::IsSet,
-    St::CreatedAt: attestation_state::IsSet,
-    St::Address: attestation_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Attestation<S> {
diff --git a/crates/jacquard-api/src/org_impactindexer/review.rs b/crates/jacquard-api/src/org_impactindexer/review.rs
index f71504f3..c9e5fdff 100644
--- a/crates/jacquard-api/src/org_impactindexer/review.rs
+++ b/crates/jacquard-api/src/org_impactindexer/review.rs
@@ -171,37 +171,37 @@ pub mod subject_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type Uri;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type Uri = St::Uri;
+        type Type = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Type = St::Type;
         type Uri = Set<members::uri>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Uri = St::Uri;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -284,8 +284,8 @@ where
 impl<S: BosStr, St> SubjectRefBuilder<S, St>
 where
     St: subject_ref_state::State,
-    St::Type: subject_ref_state::IsSet,
     St::Uri: subject_ref_state::IsSet,
+    St::Type: subject_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubjectRef<S> {
diff --git a/crates/jacquard-api/src/org_impactindexer/review/like.rs b/crates/jacquard-api/src/org_impactindexer/review/like.rs
index abfee9bc..2ba68f37 100644
--- a/crates/jacquard-api/src/org_impactindexer/review/like.rs
+++ b/crates/jacquard-api/src/org_impactindexer/review/like.rs
@@ -115,37 +115,37 @@ pub mod like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -215,8 +215,8 @@ where
 impl<S: BosStr, St> LikeBuilder<S, St>
 where
     St: like_state::State,
-    St::CreatedAt: like_state::IsSet,
     St::Subject: like_state::IsSet,
+    St::CreatedAt: like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Like<S> {
diff --git a/crates/jacquard-api/src/org_okazu_diary/feed/like.rs b/crates/jacquard-api/src/org_okazu_diary/feed/like.rs
index 379dbece..897f40f0 100644
--- a/crates/jacquard-api/src/org_okazu_diary/feed/like.rs
+++ b/crates/jacquard-api/src/org_okazu_diary/feed/like.rs
@@ -115,37 +115,37 @@ pub mod like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -228,8 +228,8 @@ impl<S: BosStr, St: like_state::State> LikeBuilder<S, St> {
 impl<S: BosStr, St> LikeBuilder<S, St>
 where
     St: like_state::State,
-    St::Subject: like_state::IsSet,
     St::CreatedAt: like_state::IsSet,
+    St::Subject: like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Like<S> {
diff --git a/crates/jacquard-api/src/org_okazu_diary/material/collection_item.rs b/crates/jacquard-api/src/org_okazu_diary/material/collection_item.rs
index c25d86a5..fbec8a3b 100644
--- a/crates/jacquard-api/src/org_okazu_diary/material/collection_item.rs
+++ b/crates/jacquard-api/src/org_okazu_diary/material/collection_item.rs
@@ -166,51 +166,51 @@ pub mod collection_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subjects;
         type Collection;
         type CreatedAt;
+        type Subjects;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subjects = Unset;
         type Collection = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subjects` field to Set
-    pub struct SetSubjects<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubjects<St> {}
-    impl<St: State> State for SetSubjects<St> {
-        type Subjects = Set<members::subjects>;
-        type Collection = St::Collection;
-        type CreatedAt = St::CreatedAt;
+        type Subjects = Unset;
     }
     ///State transition - sets the `collection` field to Set
     pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCollection<St> {}
     impl<St: State> State for SetCollection<St> {
-        type Subjects = St::Subjects;
         type Collection = Set<members::collection>;
         type CreatedAt = St::CreatedAt;
+        type Subjects = St::Subjects;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subjects = St::Subjects;
         type Collection = St::Collection;
         type CreatedAt = Set<members::created_at>;
+        type Subjects = St::Subjects;
+    }
+    ///State transition - sets the `subjects` field to Set
+    pub struct SetSubjects<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubjects<St> {}
+    impl<St: State> State for SetSubjects<St> {
+        type Collection = St::Collection;
+        type CreatedAt = St::CreatedAt;
+        type Subjects = Set<members::subjects>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subjects` field
-        pub struct subjects(());
         ///Marker type for the `collection` field
         pub struct collection(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subjects` field
+        pub struct subjects(());
     }
 }
 
@@ -331,9 +331,9 @@ impl<S: BosStr, St: collection_item_state::State> CollectionItemBuilder<S, St> {
 impl<S: BosStr, St> CollectionItemBuilder<S, St>
 where
     St: collection_item_state::State,
-    St::Subjects: collection_item_state::IsSet,
     St::Collection: collection_item_state::IsSet,
     St::CreatedAt: collection_item_state::IsSet,
+    St::Subjects: collection_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionItem<S> {
diff --git a/crates/jacquard-api/src/org_passingreads.rs b/crates/jacquard-api/src/org_passingreads.rs
index 5063a15e..c3cf70c4 100644
--- a/crates/jacquard-api/src/org_passingreads.rs
+++ b/crates/jacquard-api/src/org_passingreads.rs
@@ -566,37 +566,37 @@ pub mod location_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type H3;
         type BookCount;
+        type H3;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type H3 = Unset;
         type BookCount = Unset;
-    }
-    ///State transition - sets the `h3` field to Set
-    pub struct SetH3<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetH3<St> {}
-    impl<St: State> State for SetH3<St> {
-        type H3 = Set<members::h3>;
-        type BookCount = St::BookCount;
+        type H3 = Unset;
     }
     ///State transition - sets the `book_count` field to Set
     pub struct SetBookCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBookCount<St> {}
     impl<St: State> State for SetBookCount<St> {
-        type H3 = St::H3;
         type BookCount = Set<members::book_count>;
+        type H3 = St::H3;
+    }
+    ///State transition - sets the `h3` field to Set
+    pub struct SetH3<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetH3<St> {}
+    impl<St: State> State for SetH3<St> {
+        type BookCount = St::BookCount;
+        type H3 = Set<members::h3>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `h3` field
-        pub struct h3(());
         ///Marker type for the `book_count` field
         pub struct book_count(());
+        ///Marker type for the `h3` field
+        pub struct h3(());
     }
 }
 
@@ -666,8 +666,8 @@ where
 impl<S: BosStr, St> LocationEntryBuilder<S, St>
 where
     St: location_entry_state::State,
-    St::H3: location_entry_state::IsSet,
     St::BookCount: location_entry_state::IsSet,
+    St::H3: location_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LocationEntry<S> {
diff --git a/crates/jacquard-api/src/org_passingreads/book.rs b/crates/jacquard-api/src/org_passingreads/book.rs
index 035d321f..1926e1d6 100644
--- a/crates/jacquard-api/src/org_passingreads/book.rs
+++ b/crates/jacquard-api/src/org_passingreads/book.rs
@@ -353,84 +353,84 @@ pub mod confirmed_event_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Event;
+        type Location;
         type OccurredAt;
         type Uri;
         type Actor;
-        type Location;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Event = Unset;
+        type Location = Unset;
         type OccurredAt = Unset;
         type Uri = Unset;
         type Actor = Unset;
-        type Location = Unset;
     }
     ///State transition - sets the `event` field to Set
     pub struct SetEvent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvent<St> {}
     impl<St: State> State for SetEvent<St> {
         type Event = Set<members::event>;
+        type Location = St::Location;
+        type OccurredAt = St::OccurredAt;
+        type Uri = St::Uri;
+        type Actor = St::Actor;
+    }
+    ///State transition - sets the `location` field to Set
+    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLocation<St> {}
+    impl<St: State> State for SetLocation<St> {
+        type Event = St::Event;
+        type Location = Set<members::location>;
         type OccurredAt = St::OccurredAt;
         type Uri = St::Uri;
         type Actor = St::Actor;
-        type Location = St::Location;
     }
     ///State transition - sets the `occurred_at` field to Set
     pub struct SetOccurredAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOccurredAt<St> {}
     impl<St: State> State for SetOccurredAt<St> {
         type Event = St::Event;
+        type Location = St::Location;
         type OccurredAt = Set<members::occurred_at>;
         type Uri = St::Uri;
         type Actor = St::Actor;
-        type Location = St::Location;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Event = St::Event;
+        type Location = St::Location;
         type OccurredAt = St::OccurredAt;
         type Uri = Set<members::uri>;
         type Actor = St::Actor;
-        type Location = St::Location;
     }
     ///State transition - sets the `actor` field to Set
     pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActor<St> {}
     impl<St: State> State for SetActor<St> {
         type Event = St::Event;
-        type OccurredAt = St::OccurredAt;
-        type Uri = St::Uri;
-        type Actor = Set<members::actor>;
         type Location = St::Location;
-    }
-    ///State transition - sets the `location` field to Set
-    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLocation<St> {}
-    impl<St: State> State for SetLocation<St> {
-        type Event = St::Event;
         type OccurredAt = St::OccurredAt;
         type Uri = St::Uri;
-        type Actor = St::Actor;
-        type Location = Set<members::location>;
+        type Actor = Set<members::actor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `event` field
         pub struct event(());
+        ///Marker type for the `location` field
+        pub struct location(());
         ///Marker type for the `occurred_at` field
         pub struct occurred_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `actor` field
         pub struct actor(());
-        ///Marker type for the `location` field
-        pub struct location(());
     }
 }
 
@@ -564,10 +564,10 @@ impl<S: BosStr, St> ConfirmedEventBuilder<S, St>
 where
     St: confirmed_event_state::State,
     St::Event: confirmed_event_state::IsSet,
+    St::Location: confirmed_event_state::IsSet,
     St::OccurredAt: confirmed_event_state::IsSet,
     St::Uri: confirmed_event_state::IsSet,
     St::Actor: confirmed_event_state::IsSet,
-    St::Location: confirmed_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ConfirmedEvent<S> {
@@ -897,9 +897,9 @@ pub mod registration_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type OccurredAt;
-        type Authors;
         type BookId;
+        type Authors;
+        type OccurredAt;
         type Title;
         type RegisteredBy;
     }
@@ -907,19 +907,19 @@ pub mod registration_view_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type OccurredAt = Unset;
-        type Authors = Unset;
         type BookId = Unset;
+        type Authors = Unset;
+        type OccurredAt = Unset;
         type Title = Unset;
         type RegisteredBy = Unset;
     }
-    ///State transition - sets the `occurred_at` field to Set
-    pub struct SetOccurredAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOccurredAt<St> {}
-    impl<St: State> State for SetOccurredAt<St> {
-        type OccurredAt = Set<members::occurred_at>;
+    ///State transition - sets the `book_id` field to Set
+    pub struct SetBookId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBookId<St> {}
+    impl<St: State> State for SetBookId<St> {
+        type BookId = Set<members::book_id>;
         type Authors = St::Authors;
-        type BookId = St::BookId;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
         type RegisteredBy = St::RegisteredBy;
     }
@@ -927,19 +927,19 @@ pub mod registration_view_state {
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
-        type OccurredAt = St::OccurredAt;
-        type Authors = Set<members::authors>;
         type BookId = St::BookId;
+        type Authors = Set<members::authors>;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
         type RegisteredBy = St::RegisteredBy;
     }
-    ///State transition - sets the `book_id` field to Set
-    pub struct SetBookId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBookId<St> {}
-    impl<St: State> State for SetBookId<St> {
-        type OccurredAt = St::OccurredAt;
+    ///State transition - sets the `occurred_at` field to Set
+    pub struct SetOccurredAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOccurredAt<St> {}
+    impl<St: State> State for SetOccurredAt<St> {
+        type BookId = St::BookId;
         type Authors = St::Authors;
-        type BookId = Set<members::book_id>;
+        type OccurredAt = Set<members::occurred_at>;
         type Title = St::Title;
         type RegisteredBy = St::RegisteredBy;
     }
@@ -947,9 +947,9 @@ pub mod registration_view_state {
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type OccurredAt = St::OccurredAt;
-        type Authors = St::Authors;
         type BookId = St::BookId;
+        type Authors = St::Authors;
+        type OccurredAt = St::OccurredAt;
         type Title = Set<members::title>;
         type RegisteredBy = St::RegisteredBy;
     }
@@ -957,21 +957,21 @@ pub mod registration_view_state {
     pub struct SetRegisteredBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRegisteredBy<St> {}
     impl<St: State> State for SetRegisteredBy<St> {
-        type OccurredAt = St::OccurredAt;
-        type Authors = St::Authors;
         type BookId = St::BookId;
+        type Authors = St::Authors;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
         type RegisteredBy = Set<members::registered_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `occurred_at` field
-        pub struct occurred_at(());
-        ///Marker type for the `authors` field
-        pub struct authors(());
         ///Marker type for the `book_id` field
         pub struct book_id(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
+        ///Marker type for the `occurred_at` field
+        pub struct occurred_at(());
         ///Marker type for the `title` field
         pub struct title(());
         ///Marker type for the `registered_by` field
@@ -1122,9 +1122,9 @@ where
 impl<S: BosStr, St> RegistrationViewBuilder<S, St>
 where
     St: registration_view_state::State,
-    St::OccurredAt: registration_view_state::IsSet,
-    St::Authors: registration_view_state::IsSet,
     St::BookId: registration_view_state::IsSet,
+    St::Authors: registration_view_state::IsSet,
+    St::OccurredAt: registration_view_state::IsSet,
     St::Title: registration_view_state::IsSet,
     St::RegisteredBy: registration_view_state::IsSet,
 {
@@ -1167,9 +1167,9 @@ pub mod stateful_book_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Cid;
         type Registration;
         type Uri;
-        type Cid;
         type State;
         type CurrentHolder;
     }
@@ -1177,19 +1177,29 @@ pub mod stateful_book_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Cid = Unset;
         type Registration = Unset;
         type Uri = Unset;
-        type Cid = Unset;
         type State = Unset;
         type CurrentHolder = Unset;
     }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
+        type Registration = St::Registration;
+        type Uri = St::Uri;
+        type State = St::State;
+        type CurrentHolder = St::CurrentHolder;
+    }
     ///State transition - sets the `registration` field to Set
     pub struct SetRegistration<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRegistration<St> {}
     impl<St: State> State for SetRegistration<St> {
+        type Cid = St::Cid;
         type Registration = Set<members::registration>;
         type Uri = St::Uri;
-        type Cid = St::Cid;
         type State = St::State;
         type CurrentHolder = St::CurrentHolder;
     }
@@ -1197,19 +1207,9 @@ pub mod stateful_book_state {
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Registration = St::Registration;
-        type Uri = Set<members::uri>;
         type Cid = St::Cid;
-        type State = St::State;
-        type CurrentHolder = St::CurrentHolder;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
         type Registration = St::Registration;
-        type Uri = St::Uri;
-        type Cid = Set<members::cid>;
+        type Uri = Set<members::uri>;
         type State = St::State;
         type CurrentHolder = St::CurrentHolder;
     }
@@ -1217,9 +1217,9 @@ pub mod stateful_book_state {
     pub struct SetState<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetState<St> {}
     impl<St: State> State for SetState<St> {
+        type Cid = St::Cid;
         type Registration = St::Registration;
         type Uri = St::Uri;
-        type Cid = St::Cid;
         type State = Set<members::state>;
         type CurrentHolder = St::CurrentHolder;
     }
@@ -1227,21 +1227,21 @@ pub mod stateful_book_state {
     pub struct SetCurrentHolder<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCurrentHolder<St> {}
     impl<St: State> State for SetCurrentHolder<St> {
+        type Cid = St::Cid;
         type Registration = St::Registration;
         type Uri = St::Uri;
-        type Cid = St::Cid;
         type State = St::State;
         type CurrentHolder = Set<members::current_holder>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `registration` field
         pub struct registration(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `state` field
         pub struct state(());
         ///Marker type for the `current_holder` field
@@ -1437,9 +1437,9 @@ where
 impl<S: BosStr, St> StatefulBookBuilder<S, St>
 where
     St: stateful_book_state::State,
+    St::Cid: stateful_book_state::IsSet,
     St::Registration: stateful_book_state::IsSet,
     St::Uri: stateful_book_state::IsSet,
-    St::Cid: stateful_book_state::IsSet,
     St::State: stateful_book_state::IsSet,
     St::CurrentHolder: stateful_book_state::IsSet,
 {
diff --git a/crates/jacquard-api/src/org_passingreads/book/event.rs b/crates/jacquard-api/src/org_passingreads/book/event.rs
index 40b34863..d5313970 100644
--- a/crates/jacquard-api/src/org_passingreads/book/event.rs
+++ b/crates/jacquard-api/src/org_passingreads/book/event.rs
@@ -262,105 +262,105 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type BookSig;
+        type BookPub;
         type Book;
+        type Location;
         type OccurredAt;
         type Did;
-        type Location;
-        type BookPub;
+        type BookSig;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type BookSig = Unset;
+        type BookPub = Unset;
         type Book = Unset;
+        type Location = Unset;
         type OccurredAt = Unset;
         type Did = Unset;
-        type Location = Unset;
-        type BookPub = Unset;
+        type BookSig = Unset;
     }
-    ///State transition - sets the `book_sig` field to Set
-    pub struct SetBookSig<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBookSig<St> {}
-    impl<St: State> State for SetBookSig<St> {
-        type BookSig = Set<members::book_sig>;
+    ///State transition - sets the `book_pub` field to Set
+    pub struct SetBookPub<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBookPub<St> {}
+    impl<St: State> State for SetBookPub<St> {
+        type BookPub = Set<members::book_pub>;
         type Book = St::Book;
+        type Location = St::Location;
         type OccurredAt = St::OccurredAt;
         type Did = St::Did;
-        type Location = St::Location;
-        type BookPub = St::BookPub;
+        type BookSig = St::BookSig;
     }
     ///State transition - sets the `book` field to Set
     pub struct SetBook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBook<St> {}
     impl<St: State> State for SetBook<St> {
-        type BookSig = St::BookSig;
+        type BookPub = St::BookPub;
         type Book = Set<members::book>;
+        type Location = St::Location;
         type OccurredAt = St::OccurredAt;
         type Did = St::Did;
-        type Location = St::Location;
+        type BookSig = St::BookSig;
+    }
+    ///State transition - sets the `location` field to Set
+    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLocation<St> {}
+    impl<St: State> State for SetLocation<St> {
         type BookPub = St::BookPub;
+        type Book = St::Book;
+        type Location = Set<members::location>;
+        type OccurredAt = St::OccurredAt;
+        type Did = St::Did;
+        type BookSig = St::BookSig;
     }
     ///State transition - sets the `occurred_at` field to Set
     pub struct SetOccurredAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOccurredAt<St> {}
     impl<St: State> State for SetOccurredAt<St> {
-        type BookSig = St::BookSig;
+        type BookPub = St::BookPub;
         type Book = St::Book;
+        type Location = St::Location;
         type OccurredAt = Set<members::occurred_at>;
         type Did = St::Did;
-        type Location = St::Location;
-        type BookPub = St::BookPub;
+        type BookSig = St::BookSig;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type BookSig = St::BookSig;
+        type BookPub = St::BookPub;
         type Book = St::Book;
+        type Location = St::Location;
         type OccurredAt = St::OccurredAt;
         type Did = Set<members::did>;
-        type Location = St::Location;
-        type BookPub = St::BookPub;
-    }
-    ///State transition - sets the `location` field to Set
-    pub struct SetLocation<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLocation<St> {}
-    impl<St: State> State for SetLocation<St> {
         type BookSig = St::BookSig;
-        type Book = St::Book;
-        type OccurredAt = St::OccurredAt;
-        type Did = St::Did;
-        type Location = Set<members::location>;
-        type BookPub = St::BookPub;
     }
-    ///State transition - sets the `book_pub` field to Set
-    pub struct SetBookPub<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBookPub<St> {}
-    impl<St: State> State for SetBookPub<St> {
-        type BookSig = St::BookSig;
+    ///State transition - sets the `book_sig` field to Set
+    pub struct SetBookSig<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBookSig<St> {}
+    impl<St: State> State for SetBookSig<St> {
+        type BookPub = St::BookPub;
         type Book = St::Book;
+        type Location = St::Location;
         type OccurredAt = St::OccurredAt;
         type Did = St::Did;
-        type Location = St::Location;
-        type BookPub = Set<members::book_pub>;
+        type BookSig = Set<members::book_sig>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `book_sig` field
-        pub struct book_sig(());
+        ///Marker type for the `book_pub` field
+        pub struct book_pub(());
         ///Marker type for the `book` field
         pub struct book(());
+        ///Marker type for the `location` field
+        pub struct location(());
         ///Marker type for the `occurred_at` field
         pub struct occurred_at(());
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `location` field
-        pub struct location(());
-        ///Marker type for the `book_pub` field
-        pub struct book_pub(());
+        ///Marker type for the `book_sig` field
+        pub struct book_sig(());
     }
 }
 
@@ -527,12 +527,12 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::BookSig: event_state::IsSet,
+    St::BookPub: event_state::IsSet,
     St::Book: event_state::IsSet,
+    St::Location: event_state::IsSet,
     St::OccurredAt: event_state::IsSet,
     St::Did: event_state::IsSet,
-    St::Location: event_state::IsSet,
-    St::BookPub: event_state::IsSet,
+    St::BookSig: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/org_passingreads/book/registration.rs b/crates/jacquard-api/src/org_passingreads/book/registration.rs
index 3903402e..6cdb0202 100644
--- a/crates/jacquard-api/src/org_passingreads/book/registration.rs
+++ b/crates/jacquard-api/src/org_passingreads/book/registration.rs
@@ -198,151 +198,151 @@ pub mod registration_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
-        type Authors;
-        type OccurredAt;
         type BookId;
+        type BookSig;
+        type OccurredAt;
         type Title;
-        type PublicationId;
+        type Authors;
         type BookPub;
-        type BookSig;
+        type PublicationId;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
-        type Authors = Unset;
-        type OccurredAt = Unset;
         type BookId = Unset;
+        type BookSig = Unset;
+        type OccurredAt = Unset;
         type Title = Unset;
-        type PublicationId = Unset;
+        type Authors = Unset;
         type BookPub = Unset;
-        type BookSig = Unset;
+        type PublicationId = Unset;
+        type Did = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Authors = St::Authors;
+    ///State transition - sets the `book_id` field to Set
+    pub struct SetBookId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBookId<St> {}
+    impl<St: State> State for SetBookId<St> {
+        type BookId = Set<members::book_id>;
+        type BookSig = St::BookSig;
         type OccurredAt = St::OccurredAt;
-        type BookId = St::BookId;
         type Title = St::Title;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = St::BookPub;
-        type BookSig = St::BookSig;
-    }
-    ///State transition - sets the `authors` field to Set
-    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthors<St> {}
-    impl<St: State> State for SetAuthors<St> {
+        type PublicationId = St::PublicationId;
         type Did = St::Did;
-        type Authors = Set<members::authors>;
-        type OccurredAt = St::OccurredAt;
+    }
+    ///State transition - sets the `book_sig` field to Set
+    pub struct SetBookSig<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBookSig<St> {}
+    impl<St: State> State for SetBookSig<St> {
         type BookId = St::BookId;
+        type BookSig = Set<members::book_sig>;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = St::BookPub;
-        type BookSig = St::BookSig;
+        type PublicationId = St::PublicationId;
+        type Did = St::Did;
     }
     ///State transition - sets the `occurred_at` field to Set
     pub struct SetOccurredAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOccurredAt<St> {}
     impl<St: State> State for SetOccurredAt<St> {
-        type Did = St::Did;
-        type Authors = St::Authors;
-        type OccurredAt = Set<members::occurred_at>;
         type BookId = St::BookId;
-        type Title = St::Title;
-        type PublicationId = St::PublicationId;
-        type BookPub = St::BookPub;
         type BookSig = St::BookSig;
-    }
-    ///State transition - sets the `book_id` field to Set
-    pub struct SetBookId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBookId<St> {}
-    impl<St: State> State for SetBookId<St> {
-        type Did = St::Did;
-        type Authors = St::Authors;
-        type OccurredAt = St::OccurredAt;
-        type BookId = Set<members::book_id>;
+        type OccurredAt = Set<members::occurred_at>;
         type Title = St::Title;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = St::BookPub;
-        type BookSig = St::BookSig;
+        type PublicationId = St::PublicationId;
+        type Did = St::Did;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Did = St::Did;
-        type Authors = St::Authors;
-        type OccurredAt = St::OccurredAt;
         type BookId = St::BookId;
+        type BookSig = St::BookSig;
+        type OccurredAt = St::OccurredAt;
         type Title = Set<members::title>;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = St::BookPub;
-        type BookSig = St::BookSig;
-    }
-    ///State transition - sets the `publication_id` field to Set
-    pub struct SetPublicationId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPublicationId<St> {}
-    impl<St: State> State for SetPublicationId<St> {
+        type PublicationId = St::PublicationId;
         type Did = St::Did;
-        type Authors = St::Authors;
-        type OccurredAt = St::OccurredAt;
+    }
+    ///State transition - sets the `authors` field to Set
+    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthors<St> {}
+    impl<St: State> State for SetAuthors<St> {
         type BookId = St::BookId;
+        type BookSig = St::BookSig;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
-        type PublicationId = Set<members::publication_id>;
+        type Authors = Set<members::authors>;
         type BookPub = St::BookPub;
-        type BookSig = St::BookSig;
+        type PublicationId = St::PublicationId;
+        type Did = St::Did;
     }
     ///State transition - sets the `book_pub` field to Set
     pub struct SetBookPub<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBookPub<St> {}
     impl<St: State> State for SetBookPub<St> {
-        type Did = St::Did;
-        type Authors = St::Authors;
-        type OccurredAt = St::OccurredAt;
         type BookId = St::BookId;
+        type BookSig = St::BookSig;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = Set<members::book_pub>;
-        type BookSig = St::BookSig;
-    }
-    ///State transition - sets the `book_sig` field to Set
-    pub struct SetBookSig<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBookSig<St> {}
-    impl<St: State> State for SetBookSig<St> {
+        type PublicationId = St::PublicationId;
         type Did = St::Did;
-        type Authors = St::Authors;
+    }
+    ///State transition - sets the `publication_id` field to Set
+    pub struct SetPublicationId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPublicationId<St> {}
+    impl<St: State> State for SetPublicationId<St> {
+        type BookId = St::BookId;
+        type BookSig = St::BookSig;
         type OccurredAt = St::OccurredAt;
+        type Title = St::Title;
+        type Authors = St::Authors;
+        type BookPub = St::BookPub;
+        type PublicationId = Set<members::publication_id>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
         type BookId = St::BookId;
+        type BookSig = St::BookSig;
+        type OccurredAt = St::OccurredAt;
         type Title = St::Title;
-        type PublicationId = St::PublicationId;
+        type Authors = St::Authors;
         type BookPub = St::BookPub;
-        type BookSig = Set<members::book_sig>;
+        type PublicationId = St::PublicationId;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
-        ///Marker type for the `authors` field
-        pub struct authors(());
-        ///Marker type for the `occurred_at` field
-        pub struct occurred_at(());
         ///Marker type for the `book_id` field
         pub struct book_id(());
+        ///Marker type for the `book_sig` field
+        pub struct book_sig(());
+        ///Marker type for the `occurred_at` field
+        pub struct occurred_at(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `publication_id` field
-        pub struct publication_id(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
         ///Marker type for the `book_pub` field
         pub struct book_pub(());
-        ///Marker type for the `book_sig` field
-        pub struct book_sig(());
+        ///Marker type for the `publication_id` field
+        pub struct publication_id(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -563,14 +563,14 @@ where
 impl<S: BosStr, St> RegistrationBuilder<S, St>
 where
     St: registration_state::State,
-    St::Did: registration_state::IsSet,
-    St::Authors: registration_state::IsSet,
-    St::OccurredAt: registration_state::IsSet,
     St::BookId: registration_state::IsSet,
+    St::BookSig: registration_state::IsSet,
+    St::OccurredAt: registration_state::IsSet,
     St::Title: registration_state::IsSet,
-    St::PublicationId: registration_state::IsSet,
+    St::Authors: registration_state::IsSet,
     St::BookPub: registration_state::IsSet,
-    St::BookSig: registration_state::IsSet,
+    St::PublicationId: registration_state::IsSet,
+    St::Did: registration_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Registration<S> {
diff --git a/crates/jacquard-api/src/org_simocracy/event.rs b/crates/jacquard-api/src/org_simocracy/event.rs
index fb2c2355..6bf1c851 100644
--- a/crates/jacquard-api/src/org_simocracy/event.rs
+++ b/crates/jacquard-api/src/org_simocracy/event.rs
@@ -189,65 +189,65 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type ActorDid;
         type CreatedAt;
         type Type;
-        type ActorDid;
         type SimNames;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type ActorDid = Unset;
         type CreatedAt = Unset;
         type Type = Unset;
-        type ActorDid = Unset;
         type SimNames = Unset;
     }
+    ///State transition - sets the `actor_did` field to Set
+    pub struct SetActorDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActorDid<St> {}
+    impl<St: State> State for SetActorDid<St> {
+        type ActorDid = Set<members::actor_did>;
+        type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
+        type SimNames = St::SimNames;
+    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type ActorDid = St::ActorDid;
         type CreatedAt = Set<members::created_at>;
         type Type = St::Type;
-        type ActorDid = St::ActorDid;
         type SimNames = St::SimNames;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type CreatedAt = St::CreatedAt;
-        type Type = Set<members::r#type>;
         type ActorDid = St::ActorDid;
-        type SimNames = St::SimNames;
-    }
-    ///State transition - sets the `actor_did` field to Set
-    pub struct SetActorDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActorDid<St> {}
-    impl<St: State> State for SetActorDid<St> {
         type CreatedAt = St::CreatedAt;
-        type Type = St::Type;
-        type ActorDid = Set<members::actor_did>;
+        type Type = Set<members::r#type>;
         type SimNames = St::SimNames;
     }
     ///State transition - sets the `sim_names` field to Set
     pub struct SetSimNames<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSimNames<St> {}
     impl<St: State> State for SetSimNames<St> {
+        type ActorDid = St::ActorDid;
         type CreatedAt = St::CreatedAt;
         type Type = St::Type;
-        type ActorDid = St::ActorDid;
         type SimNames = Set<members::sim_names>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `actor_did` field
+        pub struct actor_did(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `type` field
         pub struct r#type(());
-        ///Marker type for the `actor_did` field
-        pub struct actor_did(());
         ///Marker type for the `sim_names` field
         pub struct sim_names(());
     }
@@ -432,9 +432,9 @@ impl<S: BosStr, St: event_state::State> EventBuilder<S, St> {
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
+    St::ActorDid: event_state::IsSet,
     St::CreatedAt: event_state::IsSet,
     St::Type: event_state::IsSet,
-    St::ActorDid: event_state::IsSet,
     St::SimNames: event_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/org_simocracy/interview.rs b/crates/jacquard-api/src/org_simocracy/interview.rs
index 747223c9..3878962a 100644
--- a/crates/jacquard-api/src/org_simocracy/interview.rs
+++ b/crates/jacquard-api/src/org_simocracy/interview.rs
@@ -223,66 +223,66 @@ pub mod interview_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Sim;
-        type OpenAnswers;
         type YesNoAnswers;
         type CreatedAt;
+        type OpenAnswers;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Sim = Unset;
-        type OpenAnswers = Unset;
         type YesNoAnswers = Unset;
         type CreatedAt = Unset;
+        type OpenAnswers = Unset;
     }
     ///State transition - sets the `sim` field to Set
     pub struct SetSim<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSim<St> {}
     impl<St: State> State for SetSim<St> {
         type Sim = Set<members::sim>;
-        type OpenAnswers = St::OpenAnswers;
-        type YesNoAnswers = St::YesNoAnswers;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `open_answers` field to Set
-    pub struct SetOpenAnswers<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOpenAnswers<St> {}
-    impl<St: State> State for SetOpenAnswers<St> {
-        type Sim = St::Sim;
-        type OpenAnswers = Set<members::open_answers>;
         type YesNoAnswers = St::YesNoAnswers;
         type CreatedAt = St::CreatedAt;
+        type OpenAnswers = St::OpenAnswers;
     }
     ///State transition - sets the `yes_no_answers` field to Set
     pub struct SetYesNoAnswers<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetYesNoAnswers<St> {}
     impl<St: State> State for SetYesNoAnswers<St> {
         type Sim = St::Sim;
-        type OpenAnswers = St::OpenAnswers;
         type YesNoAnswers = Set<members::yes_no_answers>;
         type CreatedAt = St::CreatedAt;
+        type OpenAnswers = St::OpenAnswers;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Sim = St::Sim;
-        type OpenAnswers = St::OpenAnswers;
         type YesNoAnswers = St::YesNoAnswers;
         type CreatedAt = Set<members::created_at>;
+        type OpenAnswers = St::OpenAnswers;
+    }
+    ///State transition - sets the `open_answers` field to Set
+    pub struct SetOpenAnswers<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOpenAnswers<St> {}
+    impl<St: State> State for SetOpenAnswers<St> {
+        type Sim = St::Sim;
+        type YesNoAnswers = St::YesNoAnswers;
+        type CreatedAt = St::CreatedAt;
+        type OpenAnswers = Set<members::open_answers>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `sim` field
         pub struct sim(());
-        ///Marker type for the `open_answers` field
-        pub struct open_answers(());
         ///Marker type for the `yes_no_answers` field
         pub struct yes_no_answers(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `open_answers` field
+        pub struct open_answers(());
     }
 }
 
@@ -396,9 +396,9 @@ impl<S: BosStr, St> InterviewBuilder<S, St>
 where
     St: interview_state::State,
     St::Sim: interview_state::IsSet,
-    St::OpenAnswers: interview_state::IsSet,
     St::YesNoAnswers: interview_state::IsSet,
     St::CreatedAt: interview_state::IsSet,
+    St::OpenAnswers: interview_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Interview<S> {
diff --git a/crates/jacquard-api/src/org_simocracy/senate/activity.rs b/crates/jacquard-api/src/org_simocracy/senate/activity.rs
index ff2cd289..7ff71ce9 100644
--- a/crates/jacquard-api/src/org_simocracy/senate/activity.rs
+++ b/crates/jacquard-api/src/org_simocracy/senate/activity.rs
@@ -334,51 +334,51 @@ pub mod activity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type ActivityType;
         type CommitteeSims;
         type CreatedAt;
-        type ActivityType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type ActivityType = Unset;
         type CommitteeSims = Unset;
         type CreatedAt = Unset;
-        type ActivityType = Unset;
+    }
+    ///State transition - sets the `activity_type` field to Set
+    pub struct SetActivityType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActivityType<St> {}
+    impl<St: State> State for SetActivityType<St> {
+        type ActivityType = Set<members::activity_type>;
+        type CommitteeSims = St::CommitteeSims;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `committee_sims` field to Set
     pub struct SetCommitteeSims<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCommitteeSims<St> {}
     impl<St: State> State for SetCommitteeSims<St> {
+        type ActivityType = St::ActivityType;
         type CommitteeSims = Set<members::committee_sims>;
         type CreatedAt = St::CreatedAt;
-        type ActivityType = St::ActivityType;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type CommitteeSims = St::CommitteeSims;
-        type CreatedAt = Set<members::created_at>;
         type ActivityType = St::ActivityType;
-    }
-    ///State transition - sets the `activity_type` field to Set
-    pub struct SetActivityType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActivityType<St> {}
-    impl<St: State> State for SetActivityType<St> {
         type CommitteeSims = St::CommitteeSims;
-        type CreatedAt = St::CreatedAt;
-        type ActivityType = Set<members::activity_type>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `activity_type` field
+        pub struct activity_type(());
         ///Marker type for the `committee_sims` field
         pub struct committee_sims(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `activity_type` field
-        pub struct activity_type(());
     }
 }
 
@@ -527,9 +527,9 @@ impl<S: BosStr, St: activity_state::State> ActivityBuilder<S, St> {
 impl<S: BosStr, St> ActivityBuilder<S, St>
 where
     St: activity_state::State,
+    St::ActivityType: activity_state::IsSet,
     St::CommitteeSims: activity_state::IsSet,
     St::CreatedAt: activity_state::IsSet,
-    St::ActivityType: activity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Activity<S> {
diff --git a/crates/jacquard-api/src/org_simocracy/sim.rs b/crates/jacquard-api/src/org_simocracy/sim.rs
index 99faabc6..d4320537 100644
--- a/crates/jacquard-api/src/org_simocracy/sim.rs
+++ b/crates/jacquard-api/src/org_simocracy/sim.rs
@@ -161,51 +161,51 @@ pub mod sim_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Settings;
         type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Settings = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Settings = St::Settings;
-        type CreatedAt = St::CreatedAt;
+        type Name = Unset;
     }
     ///State transition - sets the `settings` field to Set
     pub struct SetSettings<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSettings<St> {}
     impl<St: State> State for SetSettings<St> {
-        type Name = St::Name;
         type Settings = Set<members::settings>;
         type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type Settings = St::Settings;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Settings = St::Settings;
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `settings` field
         pub struct settings(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -309,9 +309,9 @@ where
 impl<S: BosStr, St> SimBuilder<S, St>
 where
     St: sim_state::State,
-    St::Name: sim_state::IsSet,
     St::Settings: sim_state::IsSet,
     St::CreatedAt: sim_state::IsSet,
+    St::Name: sim_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Sim<S> {
diff --git a/crates/jacquard-api/src/org_simocracy/skill.rs b/crates/jacquard-api/src/org_simocracy/skill.rs
index 4b6d2fe2..01d7801b 100644
--- a/crates/jacquard-api/src/org_simocracy/skill.rs
+++ b/crates/jacquard-api/src/org_simocracy/skill.rs
@@ -198,51 +198,51 @@ pub mod skill_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
         type Sim;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
         type Sim = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
-        type Sim = St::Sim;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Sim = St::Sim;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `sim` field to Set
     pub struct SetSim<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSim<St> {}
     impl<St: State> State for SetSim<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
         type Sim = Set<members::sim>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type Sim = St::Sim;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `sim` field
         pub struct sim(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -411,9 +411,9 @@ impl<S: BosStr, St: skill_state::State> SkillBuilder<S, St> {
 impl<S: BosStr, St> SkillBuilder<S, St>
 where
     St: skill_state::State,
-    St::CreatedAt: skill_state::IsSet,
     St::Name: skill_state::IsSet,
     St::Sim: skill_state::IsSet,
+    St::CreatedAt: skill_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Skill<S> {
diff --git a/crates/jacquard-api/src/org_simocracy/style.rs b/crates/jacquard-api/src/org_simocracy/style.rs
index 772455b0..8eebb708 100644
--- a/crates/jacquard-api/src/org_simocracy/style.rs
+++ b/crates/jacquard-api/src/org_simocracy/style.rs
@@ -142,51 +142,51 @@ pub mod style_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Description;
         type Sim;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Description = Unset;
         type Sim = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Description = St::Description;
+        type Sim = St::Sim;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
+        type CreatedAt = St::CreatedAt;
         type Description = Set<members::description>;
         type Sim = St::Sim;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `sim` field to Set
     pub struct SetSim<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSim<St> {}
     impl<St: State> State for SetSim<St> {
-        type Description = St::Description;
-        type Sim = Set<members::sim>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Description = St::Description;
-        type Sim = St::Sim;
-        type CreatedAt = Set<members::created_at>;
+        type Sim = Set<members::sim>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `description` field
         pub struct description(());
         ///Marker type for the `sim` field
         pub struct sim(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -291,9 +291,9 @@ where
 impl<S: BosStr, St> StyleBuilder<S, St>
 where
     St: style_state::State,
+    St::CreatedAt: style_state::IsSet,
     St::Description: style_state::IsSet,
     St::Sim: style_state::IsSet,
-    St::CreatedAt: style_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Style<S> {
diff --git a/crates/jacquard-api/src/org_stormlightlabs/malfestio/deck.rs b/crates/jacquard-api/src/org_stormlightlabs/malfestio/deck.rs
index e05bea06..07eb5cd9 100644
--- a/crates/jacquard-api/src/org_stormlightlabs/malfestio/deck.rs
+++ b/crates/jacquard-api/src/org_stormlightlabs/malfestio/deck.rs
@@ -280,37 +280,37 @@ pub mod deck_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Title;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = Set<members::title>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -495,8 +495,8 @@ impl<S: BosStr, St: deck_state::State> DeckBuilder<S, St> {
 impl<S: BosStr, St> DeckBuilder<S, St>
 where
     St: deck_state::State,
-    St::CreatedAt: deck_state::IsSet,
     St::Title: deck_state::IsSet,
+    St::CreatedAt: deck_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Deck<S> {
diff --git a/crates/jacquard-api/src/org_stormlightlabs/malfestio/thread/comment.rs b/crates/jacquard-api/src/org_stormlightlabs/malfestio/thread/comment.rs
index dfead849..6932aa20 100644
--- a/crates/jacquard-api/src/org_stormlightlabs/malfestio/thread/comment.rs
+++ b/crates/jacquard-api/src/org_stormlightlabs/malfestio/thread/comment.rs
@@ -129,49 +129,49 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Body;
+        type CreatedAt;
         type SubjectRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Body = Unset;
+        type CreatedAt = Unset;
         type SubjectRef = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Body = St::Body;
-        type SubjectRef = St::SubjectRef;
-    }
     ///State transition - sets the `body` field to Set
     pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBody<St> {}
     impl<St: State> State for SetBody<St> {
-        type CreatedAt = St::CreatedAt;
         type Body = Set<members::body>;
+        type CreatedAt = St::CreatedAt;
+        type SubjectRef = St::SubjectRef;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Body = St::Body;
+        type CreatedAt = Set<members::created_at>;
         type SubjectRef = St::SubjectRef;
     }
     ///State transition - sets the `subject_ref` field to Set
     pub struct SetSubjectRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubjectRef<St> {}
     impl<St: State> State for SetSubjectRef<St> {
-        type CreatedAt = St::CreatedAt;
         type Body = St::Body;
+        type CreatedAt = St::CreatedAt;
         type SubjectRef = Set<members::subject_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `body` field
         pub struct body(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `subject_ref` field
         pub struct subject_ref(());
     }
@@ -275,8 +275,8 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
-    St::CreatedAt: comment_state::IsSet,
     St::Body: comment_state::IsSet,
+    St::CreatedAt: comment_state::IsSet,
     St::SubjectRef: comment_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/pink_vase/pod/comment.rs b/crates/jacquard-api/src/pink_vase/pod/comment.rs
index caa93d31..cd3e3ccc 100644
--- a/crates/jacquard-api/src/pink_vase/pod/comment.rs
+++ b/crates/jacquard-api/src/pink_vase/pod/comment.rs
@@ -129,51 +129,51 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Episode;
         type CreatedAt;
         type Text;
-        type Episode;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Episode = Unset;
         type CreatedAt = Unset;
         type Text = Unset;
-        type Episode = Unset;
+    }
+    ///State transition - sets the `episode` field to Set
+    pub struct SetEpisode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEpisode<St> {}
+    impl<St: State> State for SetEpisode<St> {
+        type Episode = Set<members::episode>;
+        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Episode = St::Episode;
         type CreatedAt = Set<members::created_at>;
         type Text = St::Text;
-        type Episode = St::Episode;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
-        type CreatedAt = St::CreatedAt;
-        type Text = Set<members::text>;
         type Episode = St::Episode;
-    }
-    ///State transition - sets the `episode` field to Set
-    pub struct SetEpisode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEpisode<St> {}
-    impl<St: State> State for SetEpisode<St> {
         type CreatedAt = St::CreatedAt;
-        type Text = St::Text;
-        type Episode = Set<members::episode>;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `episode` field
+        pub struct episode(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `text` field
         pub struct text(());
-        ///Marker type for the `episode` field
-        pub struct episode(());
     }
 }
 
@@ -275,9 +275,9 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
+    St::Episode: comment_state::IsSet,
     St::CreatedAt: comment_state::IsSet,
     St::Text: comment_state::IsSet,
-    St::Episode: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/pink_vase/pod/episode.rs b/crates/jacquard-api/src/pink_vase/pod/episode.rs
index 82e54f31..c239aa85 100644
--- a/crates/jacquard-api/src/pink_vase/pod/episode.rs
+++ b/crates/jacquard-api/src/pink_vase/pod/episode.rs
@@ -280,65 +280,65 @@ pub mod episode_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Title;
         type CreatedAt;
         type Show;
-        type Title;
         type AudioUrl;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Title = Unset;
         type CreatedAt = Unset;
         type Show = Unset;
-        type Title = Unset;
         type AudioUrl = Unset;
     }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
+        type CreatedAt = St::CreatedAt;
+        type Show = St::Show;
+        type AudioUrl = St::AudioUrl;
+    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
         type CreatedAt = Set<members::created_at>;
         type Show = St::Show;
-        type Title = St::Title;
         type AudioUrl = St::AudioUrl;
     }
     ///State transition - sets the `show` field to Set
     pub struct SetShow<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetShow<St> {}
     impl<St: State> State for SetShow<St> {
-        type CreatedAt = St::CreatedAt;
-        type Show = Set<members::show>;
         type Title = St::Title;
-        type AudioUrl = St::AudioUrl;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
         type CreatedAt = St::CreatedAt;
-        type Show = St::Show;
-        type Title = Set<members::title>;
+        type Show = Set<members::show>;
         type AudioUrl = St::AudioUrl;
     }
     ///State transition - sets the `audio_url` field to Set
     pub struct SetAudioUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAudioUrl<St> {}
     impl<St: State> State for SetAudioUrl<St> {
+        type Title = St::Title;
         type CreatedAt = St::CreatedAt;
         type Show = St::Show;
-        type Title = St::Title;
         type AudioUrl = Set<members::audio_url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `show` field
         pub struct show(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `audio_url` field
         pub struct audio_url(());
     }
@@ -554,9 +554,9 @@ where
 impl<S: BosStr, St> EpisodeBuilder<S, St>
 where
     St: episode_state::State,
+    St::Title: episode_state::IsSet,
     St::CreatedAt: episode_state::IsSet,
     St::Show: episode_state::IsSet,
-    St::Title: episode_state::IsSet,
     St::AudioUrl: episode_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/pink_vase/pod/playlist.rs b/crates/jacquard-api/src/pink_vase/pod/playlist.rs
index 873ee54d..9956371e 100644
--- a/crates/jacquard-api/src/pink_vase/pod/playlist.rs
+++ b/crates/jacquard-api/src/pink_vase/pod/playlist.rs
@@ -232,51 +232,51 @@ pub mod playlist_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
         type Items;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
         type Items = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
-        type Items = St::Items;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Items = St::Items;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `items` field to Set
     pub struct SetItems<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetItems<St> {}
     impl<St: State> State for SetItems<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
         type Items = Set<members::items>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type Items = St::Items;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `items` field
         pub struct items(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -400,9 +400,9 @@ impl<S: BosStr, St: playlist_state::State> PlaylistBuilder<S, St> {
 impl<S: BosStr, St> PlaylistBuilder<S, St>
 where
     St: playlist_state::State,
-    St::CreatedAt: playlist_state::IsSet,
     St::Name: playlist_state::IsSet,
     St::Items: playlist_state::IsSet,
+    St::CreatedAt: playlist_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Playlist<S> {
diff --git a/crates/jacquard-api/src/place_atwork/endorsement.rs b/crates/jacquard-api/src/place_atwork/endorsement.rs
index f925e9e7..4686ed87 100644
--- a/crates/jacquard-api/src/place_atwork/endorsement.rs
+++ b/crates/jacquard-api/src/place_atwork/endorsement.rs
@@ -148,8 +148,8 @@ pub mod endorsement_state {
     pub trait State: sealed::Sealed {
         type Text;
         type CreatedAt;
-        type Receiver;
         type Giver;
+        type Receiver;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -157,8 +157,8 @@ pub mod endorsement_state {
     impl State for Empty {
         type Text = Unset;
         type CreatedAt = Unset;
-        type Receiver = Unset;
         type Giver = Unset;
+        type Receiver = Unset;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
@@ -166,8 +166,8 @@ pub mod endorsement_state {
     impl<St: State> State for SetText<St> {
         type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
-        type Receiver = St::Receiver;
         type Giver = St::Giver;
+        type Receiver = St::Receiver;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -175,17 +175,8 @@ pub mod endorsement_state {
     impl<St: State> State for SetCreatedAt<St> {
         type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
-        type Receiver = St::Receiver;
-        type Giver = St::Giver;
-    }
-    ///State transition - sets the `receiver` field to Set
-    pub struct SetReceiver<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReceiver<St> {}
-    impl<St: State> State for SetReceiver<St> {
-        type Text = St::Text;
-        type CreatedAt = St::CreatedAt;
-        type Receiver = Set<members::receiver>;
         type Giver = St::Giver;
+        type Receiver = St::Receiver;
     }
     ///State transition - sets the `giver` field to Set
     pub struct SetGiver<St: State = Empty>(PhantomData<fn() -> St>);
@@ -193,8 +184,17 @@ pub mod endorsement_state {
     impl<St: State> State for SetGiver<St> {
         type Text = St::Text;
         type CreatedAt = St::CreatedAt;
-        type Receiver = St::Receiver;
         type Giver = Set<members::giver>;
+        type Receiver = St::Receiver;
+    }
+    ///State transition - sets the `receiver` field to Set
+    pub struct SetReceiver<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReceiver<St> {}
+    impl<St: State> State for SetReceiver<St> {
+        type Text = St::Text;
+        type CreatedAt = St::CreatedAt;
+        type Giver = St::Giver;
+        type Receiver = Set<members::receiver>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -203,10 +203,10 @@ pub mod endorsement_state {
         pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `receiver` field
-        pub struct receiver(());
         ///Marker type for the `giver` field
         pub struct giver(());
+        ///Marker type for the `receiver` field
+        pub struct receiver(());
     }
 }
 
@@ -335,8 +335,8 @@ where
     St: endorsement_state::State,
     St::Text: endorsement_state::IsSet,
     St::CreatedAt: endorsement_state::IsSet,
-    St::Receiver: endorsement_state::IsSet,
     St::Giver: endorsement_state::IsSet,
+    St::Receiver: endorsement_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Endorsement<S> {
diff --git a/crates/jacquard-api/src/place_atwork/get_listings.rs b/crates/jacquard-api/src/place_atwork/get_listings.rs
index dc8086e5..31bbee62 100644
--- a/crates/jacquard-api/src/place_atwork/get_listings.rs
+++ b/crates/jacquard-api/src/place_atwork/get_listings.rs
@@ -110,37 +110,37 @@ pub mod listing_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
+        type Cid = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -223,8 +223,8 @@ impl<S: BosStr, St: listing_record_state::State> ListingRecordBuilder<S, St> {
 impl<S: BosStr, St> ListingRecordBuilder<S, St>
 where
     St: listing_record_state::State,
-    St::Cid: listing_record_state::IsSet,
     St::Uri: listing_record_state::IsSet,
+    St::Cid: listing_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListingRecord<S> {
diff --git a/crates/jacquard-api/src/place_atwork/listing.rs b/crates/jacquard-api/src/place_atwork/listing.rs
index c652ce25..c862e266 100644
--- a/crates/jacquard-api/src/place_atwork/listing.rs
+++ b/crates/jacquard-api/src/place_atwork/listing.rs
@@ -208,67 +208,67 @@ pub mod listing_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type NotBefore;
         type Title;
-        type NotAfter;
         type Description;
+        type NotAfter;
+        type NotBefore;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type NotBefore = Unset;
         type Title = Unset;
-        type NotAfter = Unset;
         type Description = Unset;
-    }
-    ///State transition - sets the `not_before` field to Set
-    pub struct SetNotBefore<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotBefore<St> {}
-    impl<St: State> State for SetNotBefore<St> {
-        type NotBefore = Set<members::not_before>;
-        type Title = St::Title;
-        type NotAfter = St::NotAfter;
-        type Description = St::Description;
+        type NotAfter = Unset;
+        type NotBefore = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type NotBefore = St::NotBefore;
         type Title = Set<members::title>;
-        type NotAfter = St::NotAfter;
         type Description = St::Description;
+        type NotAfter = St::NotAfter;
+        type NotBefore = St::NotBefore;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Title = St::Title;
+        type Description = Set<members::description>;
+        type NotAfter = St::NotAfter;
+        type NotBefore = St::NotBefore;
     }
     ///State transition - sets the `not_after` field to Set
     pub struct SetNotAfter<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotAfter<St> {}
     impl<St: State> State for SetNotAfter<St> {
-        type NotBefore = St::NotBefore;
         type Title = St::Title;
-        type NotAfter = Set<members::not_after>;
         type Description = St::Description;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
+        type NotAfter = Set<members::not_after>;
         type NotBefore = St::NotBefore;
+    }
+    ///State transition - sets the `not_before` field to Set
+    pub struct SetNotBefore<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotBefore<St> {}
+    impl<St: State> State for SetNotBefore<St> {
         type Title = St::Title;
+        type Description = St::Description;
         type NotAfter = St::NotAfter;
-        type Description = Set<members::description>;
+        type NotBefore = Set<members::not_before>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `not_before` field
-        pub struct not_before(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `not_after` field
-        pub struct not_after(());
         ///Marker type for the `description` field
         pub struct description(());
+        ///Marker type for the `not_after` field
+        pub struct not_after(());
+        ///Marker type for the `not_before` field
+        pub struct not_before(());
     }
 }
 
@@ -437,10 +437,10 @@ where
 impl<S: BosStr, St> ListingBuilder<S, St>
 where
     St: listing_state::State,
-    St::NotBefore: listing_state::IsSet,
     St::Title: listing_state::IsSet,
-    St::NotAfter: listing_state::IsSet,
     St::Description: listing_state::IsSet,
+    St::NotAfter: listing_state::IsSet,
+    St::NotBefore: listing_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Listing<S> {
diff --git a/crates/jacquard-api/src/place_atwork/search_listings.rs b/crates/jacquard-api/src/place_atwork/search_listings.rs
index 328ea22c..c68213b0 100644
--- a/crates/jacquard-api/src/place_atwork/search_listings.rs
+++ b/crates/jacquard-api/src/place_atwork/search_listings.rs
@@ -150,37 +150,37 @@ pub mod listing_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
+        type Cid = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -263,8 +263,8 @@ impl<S: BosStr, St: listing_record_state::State> ListingRecordBuilder<S, St> {
 impl<S: BosStr, St> ListingRecordBuilder<S, St>
 where
     St: listing_record_state::State,
-    St::Cid: listing_record_state::IsSet,
     St::Uri: listing_record_state::IsSet,
+    St::Cid: listing_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListingRecord<S> {
diff --git a/crates/jacquard-api/src/place_stream.rs b/crates/jacquard-api/src/place_stream.rs
index 9e9f2b74..d6b3e90e 100644
--- a/crates/jacquard-api/src/place_stream.rs
+++ b/crates/jacquard-api/src/place_stream.rs
@@ -131,85 +131,85 @@ pub mod block_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
+        type Record;
         type IndexedAt;
         type Cid;
         type Blocker;
-        type Record;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
+        type Record = Unset;
         type IndexedAt = Unset;
         type Cid = Unset;
         type Blocker = Unset;
-        type Record = Unset;
-        type Uri = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Blocker = St::Blocker;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Uri = St::Uri;
+        type Record = Set<members::record>;
+        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Blocker = St::Blocker;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
+        type Record = St::Record;
         type IndexedAt = Set<members::indexed_at>;
         type Cid = St::Cid;
         type Blocker = St::Blocker;
-        type Record = St::Record;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
         type Cid = Set<members::cid>;
         type Blocker = St::Blocker;
-        type Record = St::Record;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `blocker` field to Set
     pub struct SetBlocker<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlocker<St> {}
     impl<St: State> State for SetBlocker<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Blocker = Set<members::blocker>;
-        type Record = St::Record;
-        type Uri = St::Uri;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Blocker = St::Blocker;
-        type Record = Set<members::record>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
         type Cid = St::Cid;
-        type Blocker = St::Blocker;
-        type Record = St::Record;
-        type Uri = Set<members::uri>;
+        type Blocker = Set<members::blocker>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `record` field
+        pub struct record(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `blocker` field
         pub struct blocker(());
-        ///Marker type for the `record` field
-        pub struct record(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -342,11 +342,11 @@ where
 impl<S: BosStr, St> BlockViewBuilder<S, St>
 where
     St: block_view_state::State,
+    St::Uri: block_view_state::IsSet,
+    St::Record: block_view_state::IsSet,
     St::IndexedAt: block_view_state::IsSet,
     St::Cid: block_view_state::IsSet,
     St::Blocker: block_view_state::IsSet,
-    St::Record: block_view_state::IsSet,
-    St::Uri: block_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BlockView<S> {
diff --git a/crates/jacquard-api/src/place_stream/badge.rs b/crates/jacquard-api/src/place_stream/badge.rs
index 71cf596a..18962099 100644
--- a/crates/jacquard-api/src/place_stream/badge.rs
+++ b/crates/jacquard-api/src/place_stream/badge.rs
@@ -177,51 +177,51 @@ pub mod badge_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type BadgeType;
-        type Issuer;
         type Recipient;
+        type Issuer;
+        type BadgeType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type BadgeType = Unset;
-        type Issuer = Unset;
         type Recipient = Unset;
+        type Issuer = Unset;
+        type BadgeType = Unset;
     }
-    ///State transition - sets the `badge_type` field to Set
-    pub struct SetBadgeType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBadgeType<St> {}
-    impl<St: State> State for SetBadgeType<St> {
-        type BadgeType = Set<members::badge_type>;
+    ///State transition - sets the `recipient` field to Set
+    pub struct SetRecipient<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecipient<St> {}
+    impl<St: State> State for SetRecipient<St> {
+        type Recipient = Set<members::recipient>;
         type Issuer = St::Issuer;
-        type Recipient = St::Recipient;
+        type BadgeType = St::BadgeType;
     }
     ///State transition - sets the `issuer` field to Set
     pub struct SetIssuer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIssuer<St> {}
     impl<St: State> State for SetIssuer<St> {
-        type BadgeType = St::BadgeType;
-        type Issuer = Set<members::issuer>;
         type Recipient = St::Recipient;
-    }
-    ///State transition - sets the `recipient` field to Set
-    pub struct SetRecipient<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecipient<St> {}
-    impl<St: State> State for SetRecipient<St> {
+        type Issuer = Set<members::issuer>;
         type BadgeType = St::BadgeType;
+    }
+    ///State transition - sets the `badge_type` field to Set
+    pub struct SetBadgeType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBadgeType<St> {}
+    impl<St: State> State for SetBadgeType<St> {
+        type Recipient = St::Recipient;
         type Issuer = St::Issuer;
-        type Recipient = Set<members::recipient>;
+        type BadgeType = Set<members::badge_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `badge_type` field
-        pub struct badge_type(());
-        ///Marker type for the `issuer` field
-        pub struct issuer(());
         ///Marker type for the `recipient` field
         pub struct recipient(());
+        ///Marker type for the `issuer` field
+        pub struct issuer(());
+        ///Marker type for the `badge_type` field
+        pub struct badge_type(());
     }
 }
 
@@ -323,9 +323,9 @@ impl<S: BosStr, St: badge_view_state::State> BadgeViewBuilder<S, St> {
 impl<S: BosStr, St> BadgeViewBuilder<S, St>
 where
     St: badge_view_state::State,
-    St::BadgeType: badge_view_state::IsSet,
-    St::Issuer: badge_view_state::IsSet,
     St::Recipient: badge_view_state::IsSet,
+    St::Issuer: badge_view_state::IsSet,
+    St::BadgeType: badge_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BadgeView<S> {
diff --git a/crates/jacquard-api/src/place_stream/broadcast.rs b/crates/jacquard-api/src/place_stream/broadcast.rs
index 6f5167f6..ae4bc0bf 100644
--- a/crates/jacquard-api/src/place_stream/broadcast.rs
+++ b/crates/jacquard-api/src/place_stream/broadcast.rs
@@ -68,66 +68,66 @@ pub mod broadcast_origin_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Uri;
+        type Record;
         type Cid;
         type Author;
-        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Uri = Unset;
+        type Record = Unset;
         type Cid = Unset;
         type Author = Unset;
-        type Record = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Uri = Set<members::uri>;
+        type Record = St::Record;
+        type Cid = St::Cid;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Uri = St::Uri;
+        type Record = Set<members::record>;
         type Cid = St::Cid;
         type Author = St::Author;
-        type Record = St::Record;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
         type Uri = St::Uri;
+        type Record = St::Record;
         type Cid = Set<members::cid>;
         type Author = St::Author;
-        type Record = St::Record;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
         type Uri = St::Uri;
-        type Cid = St::Cid;
-        type Author = Set<members::author>;
         type Record = St::Record;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Uri = St::Uri;
         type Cid = St::Cid;
-        type Author = St::Author;
-        type Record = Set<members::record>;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `record` field
+        pub struct record(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `record` field
-        pub struct record(());
     }
 }
 
@@ -244,9 +244,9 @@ impl<S: BosStr, St> BroadcastOriginViewBuilder<S, St>
 where
     St: broadcast_origin_view_state::State,
     St::Uri: broadcast_origin_view_state::IsSet,
+    St::Record: broadcast_origin_view_state::IsSet,
     St::Cid: broadcast_origin_view_state::IsSet,
     St::Author: broadcast_origin_view_state::IsSet,
-    St::Record: broadcast_origin_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BroadcastOriginView<S> {
diff --git a/crates/jacquard-api/src/place_stream/broadcast/origin.rs b/crates/jacquard-api/src/place_stream/broadcast/origin.rs
index cee7d8ed..150d7d97 100644
--- a/crates/jacquard-api/src/place_stream/broadcast/origin.rs
+++ b/crates/jacquard-api/src/place_stream/broadcast/origin.rs
@@ -135,49 +135,49 @@ pub mod origin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Server;
         type Streamer;
+        type Server;
         type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Server = Unset;
         type Streamer = Unset;
+        type Server = Unset;
         type UpdatedAt = Unset;
     }
-    ///State transition - sets the `server` field to Set
-    pub struct SetServer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetServer<St> {}
-    impl<St: State> State for SetServer<St> {
-        type Server = Set<members::server>;
-        type Streamer = St::Streamer;
-        type UpdatedAt = St::UpdatedAt;
-    }
     ///State transition - sets the `streamer` field to Set
     pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStreamer<St> {}
     impl<St: State> State for SetStreamer<St> {
-        type Server = St::Server;
         type Streamer = Set<members::streamer>;
+        type Server = St::Server;
+        type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `server` field to Set
+    pub struct SetServer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetServer<St> {}
+    impl<St: State> State for SetServer<St> {
+        type Streamer = St::Streamer;
+        type Server = Set<members::server>;
         type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
-        type Server = St::Server;
         type Streamer = St::Streamer;
+        type Server = St::Server;
         type UpdatedAt = Set<members::updated_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `server` field
-        pub struct server(());
         ///Marker type for the `streamer` field
         pub struct streamer(());
+        ///Marker type for the `server` field
+        pub struct server(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
     }
@@ -314,8 +314,8 @@ impl<S: BosStr, St: origin_state::State> OriginBuilder<S, St> {
 impl<S: BosStr, St> OriginBuilder<S, St>
 where
     St: origin_state::State,
-    St::Server: origin_state::IsSet,
     St::Streamer: origin_state::IsSet,
+    St::Server: origin_state::IsSet,
     St::UpdatedAt: origin_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/place_stream/broadcast/syndication.rs b/crates/jacquard-api/src/place_stream/broadcast/syndication.rs
index fd79a54b..db5c43aa 100644
--- a/crates/jacquard-api/src/place_stream/broadcast/syndication.rs
+++ b/crates/jacquard-api/src/place_stream/broadcast/syndication.rs
@@ -116,51 +116,51 @@ pub mod syndication_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Streamer;
         type Broadcaster;
+        type Streamer;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Streamer = Unset;
         type Broadcaster = Unset;
+        type Streamer = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `broadcaster` field to Set
+    pub struct SetBroadcaster<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBroadcaster<St> {}
+    impl<St: State> State for SetBroadcaster<St> {
+        type Broadcaster = Set<members::broadcaster>;
         type Streamer = St::Streamer;
-        type Broadcaster = St::Broadcaster;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `streamer` field to Set
     pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStreamer<St> {}
     impl<St: State> State for SetStreamer<St> {
-        type CreatedAt = St::CreatedAt;
-        type Streamer = Set<members::streamer>;
         type Broadcaster = St::Broadcaster;
-    }
-    ///State transition - sets the `broadcaster` field to Set
-    pub struct SetBroadcaster<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBroadcaster<St> {}
-    impl<St: State> State for SetBroadcaster<St> {
+        type Streamer = Set<members::streamer>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Broadcaster = St::Broadcaster;
         type Streamer = St::Streamer;
-        type Broadcaster = Set<members::broadcaster>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `broadcaster` field
         pub struct broadcaster(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> SyndicationBuilder<S, St>
 where
     St: syndication_state::State,
-    St::CreatedAt: syndication_state::IsSet,
-    St::Streamer: syndication_state::IsSet,
     St::Broadcaster: syndication_state::IsSet,
+    St::Streamer: syndication_state::IsSet,
+    St::CreatedAt: syndication_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Syndication<S> {
diff --git a/crates/jacquard-api/src/place_stream/chat.rs b/crates/jacquard-api/src/place_stream/chat.rs
index 1e067f00..62a30b6e 100644
--- a/crates/jacquard-api/src/place_stream/chat.rs
+++ b/crates/jacquard-api/src/place_stream/chat.rs
@@ -86,85 +86,85 @@ pub mod message_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type Author;
-        type Cid;
         type IndexedAt;
+        type Cid;
         type Record;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type Author = Unset;
-        type Cid = Unset;
         type IndexedAt = Unset;
+        type Cid = Unset;
         type Record = Unset;
-        type Uri = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Author = St::Author;
+        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
+        type Record = St::Record;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Author = Set<members::author>;
-        type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Record = St::Record;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Author = St::Author;
-        type Cid = Set<members::cid>;
+        type Author = Set<members::author>;
         type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
         type Record = St::Record;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = St::Cid;
         type IndexedAt = Set<members::indexed_at>;
+        type Cid = St::Cid;
         type Record = St::Record;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Uri = St::Uri;
+        type Author = St::Author;
+        type IndexedAt = St::IndexedAt;
+        type Cid = Set<members::cid>;
+        type Record = St::Record;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Author = St::Author;
-        type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Record = Set<members::record>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Author = St::Author;
-        type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Record = St::Record;
-        type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `record` field
         pub struct record(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -339,11 +339,11 @@ where
 impl<S: BosStr, St> MessageViewBuilder<S, St>
 where
     St: message_view_state::State,
+    St::Uri: message_view_state::IsSet,
     St::Author: message_view_state::IsSet,
-    St::Cid: message_view_state::IsSet,
     St::IndexedAt: message_view_state::IsSet,
+    St::Cid: message_view_state::IsSet,
     St::Record: message_view_state::IsSet,
-    St::Uri: message_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> MessageView<S> {
diff --git a/crates/jacquard-api/src/place_stream/chat/message.rs b/crates/jacquard-api/src/place_stream/chat/message.rs
index 742dab5e..0e838f6b 100644
--- a/crates/jacquard-api/src/place_stream/chat/message.rs
+++ b/crates/jacquard-api/src/place_stream/chat/message.rs
@@ -173,51 +173,51 @@ pub mod message_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
-        type Streamer;
         type CreatedAt;
+        type Streamer;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
-        type Streamer = Unset;
         type CreatedAt = Unset;
+        type Streamer = Unset;
+        type Text = Unset;
     }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Streamer = St::Streamer;
-        type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
     }
     ///State transition - sets the `streamer` field to Set
     pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStreamer<St> {}
     impl<St: State> State for SetStreamer<St> {
-        type Text = St::Text;
-        type Streamer = Set<members::streamer>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Streamer = Set<members::streamer>;
         type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type CreatedAt = St::CreatedAt;
         type Streamer = St::Streamer;
-        type CreatedAt = Set<members::created_at>;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -338,9 +338,9 @@ where
 impl<S: BosStr, St> MessageBuilder<S, St>
 where
     St: message_state::State,
-    St::Text: message_state::IsSet,
-    St::Streamer: message_state::IsSet,
     St::CreatedAt: message_state::IsSet,
+    St::Streamer: message_state::IsSet,
+    St::Text: message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Message<S> {
diff --git a/crates/jacquard-api/src/place_stream/chat/profile.rs b/crates/jacquard-api/src/place_stream/chat/profile.rs
index bc25ba44..c9b7f920 100644
--- a/crates/jacquard-api/src/place_stream/chat/profile.rs
+++ b/crates/jacquard-api/src/place_stream/chat/profile.rs
@@ -200,51 +200,51 @@ pub mod color_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Green;
         type Blue;
         type Red;
+        type Green;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Green = Unset;
         type Blue = Unset;
         type Red = Unset;
-    }
-    ///State transition - sets the `green` field to Set
-    pub struct SetGreen<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGreen<St> {}
-    impl<St: State> State for SetGreen<St> {
-        type Green = Set<members::green>;
-        type Blue = St::Blue;
-        type Red = St::Red;
+        type Green = Unset;
     }
     ///State transition - sets the `blue` field to Set
     pub struct SetBlue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlue<St> {}
     impl<St: State> State for SetBlue<St> {
-        type Green = St::Green;
         type Blue = Set<members::blue>;
         type Red = St::Red;
+        type Green = St::Green;
     }
     ///State transition - sets the `red` field to Set
     pub struct SetRed<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRed<St> {}
     impl<St: State> State for SetRed<St> {
-        type Green = St::Green;
         type Blue = St::Blue;
         type Red = Set<members::red>;
+        type Green = St::Green;
+    }
+    ///State transition - sets the `green` field to Set
+    pub struct SetGreen<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGreen<St> {}
+    impl<St: State> State for SetGreen<St> {
+        type Blue = St::Blue;
+        type Red = St::Red;
+        type Green = Set<members::green>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `green` field
-        pub struct green(());
         ///Marker type for the `blue` field
         pub struct blue(());
         ///Marker type for the `red` field
         pub struct red(());
+        ///Marker type for the `green` field
+        pub struct green(());
     }
 }
 
@@ -333,9 +333,9 @@ where
 impl<S: BosStr, St> ColorBuilder<S, St>
 where
     St: color_state::State,
-    St::Green: color_state::IsSet,
     St::Blue: color_state::IsSet,
     St::Red: color_state::IsSet,
+    St::Green: color_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Color<S> {
diff --git a/crates/jacquard-api/src/place_stream/graph/get_following_user.rs b/crates/jacquard-api/src/place_stream/graph/get_following_user.rs
index 4d5cc7d9..07c8b643 100644
--- a/crates/jacquard-api/src/place_stream/graph/get_following_user.rs
+++ b/crates/jacquard-api/src/place_stream/graph/get_following_user.rs
@@ -69,37 +69,37 @@ pub mod get_following_user_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type UserDid;
         type SubjectDid;
+        type UserDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type UserDid = Unset;
         type SubjectDid = Unset;
-    }
-    ///State transition - sets the `user_did` field to Set
-    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUserDid<St> {}
-    impl<St: State> State for SetUserDid<St> {
-        type UserDid = Set<members::user_did>;
-        type SubjectDid = St::SubjectDid;
+        type UserDid = Unset;
     }
     ///State transition - sets the `subject_did` field to Set
     pub struct SetSubjectDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubjectDid<St> {}
     impl<St: State> State for SetSubjectDid<St> {
-        type UserDid = St::UserDid;
         type SubjectDid = Set<members::subject_did>;
+        type UserDid = St::UserDid;
+    }
+    ///State transition - sets the `user_did` field to Set
+    pub struct SetUserDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUserDid<St> {}
+    impl<St: State> State for SetUserDid<St> {
+        type SubjectDid = St::SubjectDid;
+        type UserDid = Set<members::user_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `user_did` field
-        pub struct user_did(());
         ///Marker type for the `subject_did` field
         pub struct subject_did(());
+        ///Marker type for the `user_did` field
+        pub struct user_did(());
     }
 }
 
@@ -169,8 +169,8 @@ where
 impl<S: BosStr, St> GetFollowingUserBuilder<S, St>
 where
     St: get_following_user_state::State,
-    St::UserDid: get_following_user_state::IsSet,
     St::SubjectDid: get_following_user_state::IsSet,
+    St::UserDid: get_following_user_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetFollowingUser<S> {
diff --git a/crates/jacquard-api/src/place_stream/ingest.rs b/crates/jacquard-api/src/place_stream/ingest.rs
index a2b98143..c94a1880 100644
--- a/crates/jacquard-api/src/place_stream/ingest.rs
+++ b/crates/jacquard-api/src/place_stream/ingest.rs
@@ -65,37 +65,37 @@ pub mod ingest_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type Url;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type Url = St::Url;
+        type Type = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type Type = St::Type;
         type Url = Set<members::url>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Url = St::Url;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -165,8 +165,8 @@ where
 impl<S: BosStr, St> IngestBuilder<S, St>
 where
     St: ingest_state::State,
-    St::Type: ingest_state::IsSet,
     St::Url: ingest_state::IsSet,
+    St::Type: ingest_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Ingest<S> {
diff --git a/crates/jacquard-api/src/place_stream/key.rs b/crates/jacquard-api/src/place_stream/key.rs
index 99182b9a..6b213698 100644
--- a/crates/jacquard-api/src/place_stream/key.rs
+++ b/crates/jacquard-api/src/place_stream/key.rs
@@ -139,37 +139,37 @@ pub mod key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type SigningKey;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type SigningKey = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type SigningKey = St::SigningKey;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `signing_key` field to Set
     pub struct SetSigningKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSigningKey<St> {}
     impl<St: State> State for SetSigningKey<St> {
-        type CreatedAt = St::CreatedAt;
         type SigningKey = Set<members::signing_key>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type SigningKey = St::SigningKey;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `signing_key` field
         pub struct signing_key(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -252,8 +252,8 @@ where
 impl<S: BosStr, St> KeyBuilder<S, St>
 where
     St: key_state::State,
-    St::CreatedAt: key_state::IsSet,
     St::SigningKey: key_state::IsSet,
+    St::CreatedAt: key_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Key<S> {
diff --git a/crates/jacquard-api/src/place_stream/live/start_livestream.rs b/crates/jacquard-api/src/place_stream/live/start_livestream.rs
index 255071d5..beeea8d9 100644
--- a/crates/jacquard-api/src/place_stream/live/start_livestream.rs
+++ b/crates/jacquard-api/src/place_stream/live/start_livestream.rs
@@ -81,37 +81,37 @@ pub mod start_livestream_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Streamer;
         type Livestream;
+        type Streamer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Streamer = Unset;
         type Livestream = Unset;
-    }
-    ///State transition - sets the `streamer` field to Set
-    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStreamer<St> {}
-    impl<St: State> State for SetStreamer<St> {
-        type Streamer = Set<members::streamer>;
-        type Livestream = St::Livestream;
+        type Streamer = Unset;
     }
     ///State transition - sets the `livestream` field to Set
     pub struct SetLivestream<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLivestream<St> {}
     impl<St: State> State for SetLivestream<St> {
-        type Streamer = St::Streamer;
         type Livestream = Set<members::livestream>;
+        type Streamer = St::Streamer;
+    }
+    ///State transition - sets the `streamer` field to Set
+    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStreamer<St> {}
+    impl<St: State> State for SetStreamer<St> {
+        type Livestream = St::Livestream;
+        type Streamer = Set<members::streamer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `livestream` field
         pub struct livestream(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
     }
 }
 
@@ -194,8 +194,8 @@ where
 impl<S: BosStr, St> StartLivestreamBuilder<S, St>
 where
     St: start_livestream_state::State,
-    St::Streamer: start_livestream_state::IsSet,
     St::Livestream: start_livestream_state::IsSet,
+    St::Streamer: start_livestream_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> StartLivestream<S> {
diff --git a/crates/jacquard-api/src/place_stream/live/teleport.rs b/crates/jacquard-api/src/place_stream/live/teleport.rs
index 996b8c88..c3c211d6 100644
--- a/crates/jacquard-api/src/place_stream/live/teleport.rs
+++ b/crates/jacquard-api/src/place_stream/live/teleport.rs
@@ -135,37 +135,37 @@ pub mod teleport_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StartsAt;
         type Streamer;
+        type StartsAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StartsAt = Unset;
         type Streamer = Unset;
-    }
-    ///State transition - sets the `starts_at` field to Set
-    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
-    impl<St: State> State for SetStartsAt<St> {
-        type StartsAt = Set<members::starts_at>;
-        type Streamer = St::Streamer;
+        type StartsAt = Unset;
     }
     ///State transition - sets the `streamer` field to Set
     pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStreamer<St> {}
     impl<St: State> State for SetStreamer<St> {
-        type StartsAt = St::StartsAt;
         type Streamer = Set<members::streamer>;
+        type StartsAt = St::StartsAt;
+    }
+    ///State transition - sets the `starts_at` field to Set
+    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
+    impl<St: State> State for SetStartsAt<St> {
+        type Streamer = St::Streamer;
+        type StartsAt = Set<members::starts_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `starts_at` field
-        pub struct starts_at(());
         ///Marker type for the `streamer` field
         pub struct streamer(());
+        ///Marker type for the `starts_at` field
+        pub struct starts_at(());
     }
 }
 
@@ -248,8 +248,8 @@ where
 impl<S: BosStr, St> TeleportBuilder<S, St>
 where
     St: teleport_state::State,
-    St::StartsAt: teleport_state::IsSet,
     St::Streamer: teleport_state::IsSet,
+    St::StartsAt: teleport_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Teleport<S> {
diff --git a/crates/jacquard-api/src/place_stream/livestream.rs b/crates/jacquard-api/src/place_stream/livestream.rs
index 5cd7f5ce..3174b71d 100644
--- a/crates/jacquard-api/src/place_stream/livestream.rs
+++ b/crates/jacquard-api/src/place_stream/livestream.rs
@@ -399,83 +399,83 @@ pub mod livestream_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Record;
+        type Uri;
         type Cid;
         type IndexedAt;
-        type Uri;
-        type Record;
         type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Record = Unset;
+        type Uri = Unset;
         type Cid = Unset;
         type IndexedAt = Unset;
-        type Uri = Unset;
-        type Record = Unset;
         type Author = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type IndexedAt = St::IndexedAt;
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Record = Set<members::record>;
         type Uri = St::Uri;
-        type Record = St::Record;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
         type Cid = St::Cid;
-        type IndexedAt = Set<members::indexed_at>;
-        type Uri = St::Uri;
-        type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
         type Author = St::Author;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
+        type Record = St::Record;
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Uri = Set<members::uri>;
-        type Record = St::Record;
         type Author = St::Author;
     }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Cid = St::Cid;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Record = St::Record;
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Record = St::Record;
         type Uri = St::Uri;
-        type Record = Set<members::record>;
+        type Cid = St::Cid;
+        type IndexedAt = Set<members::indexed_at>;
         type Author = St::Author;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
+        type Record = St::Record;
+        type Uri = St::Uri;
         type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
-        type Record = St::Record;
         type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `record` field
+        pub struct record(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `record` field
-        pub struct record(());
         ///Marker type for the `author` field
         pub struct author(());
     }
@@ -630,10 +630,10 @@ impl<S: BosStr, St: livestream_view_state::State> LivestreamViewBuilder<S, St> {
 impl<S: BosStr, St> LivestreamViewBuilder<S, St>
 where
     St: livestream_view_state::State,
+    St::Record: livestream_view_state::IsSet,
+    St::Uri: livestream_view_state::IsSet,
     St::Cid: livestream_view_state::IsSet,
     St::IndexedAt: livestream_view_state::IsSet,
-    St::Uri: livestream_view_state::IsSet,
-    St::Record: livestream_view_state::IsSet,
     St::Author: livestream_view_state::IsSet,
 {
     /// Build the final struct.
@@ -1436,67 +1436,67 @@ pub mod teleport_arrival_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StartsAt;
-        type TeleportUri;
         type Source;
+        type TeleportUri;
         type ViewerCount;
+        type StartsAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StartsAt = Unset;
-        type TeleportUri = Unset;
         type Source = Unset;
+        type TeleportUri = Unset;
         type ViewerCount = Unset;
+        type StartsAt = Unset;
     }
-    ///State transition - sets the `starts_at` field to Set
-    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
-    impl<St: State> State for SetStartsAt<St> {
-        type StartsAt = Set<members::starts_at>;
+    ///State transition - sets the `source` field to Set
+    pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSource<St> {}
+    impl<St: State> State for SetSource<St> {
+        type Source = Set<members::source>;
         type TeleportUri = St::TeleportUri;
-        type Source = St::Source;
         type ViewerCount = St::ViewerCount;
+        type StartsAt = St::StartsAt;
     }
     ///State transition - sets the `teleport_uri` field to Set
     pub struct SetTeleportUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTeleportUri<St> {}
     impl<St: State> State for SetTeleportUri<St> {
-        type StartsAt = St::StartsAt;
-        type TeleportUri = Set<members::teleport_uri>;
         type Source = St::Source;
+        type TeleportUri = Set<members::teleport_uri>;
         type ViewerCount = St::ViewerCount;
-    }
-    ///State transition - sets the `source` field to Set
-    pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSource<St> {}
-    impl<St: State> State for SetSource<St> {
         type StartsAt = St::StartsAt;
-        type TeleportUri = St::TeleportUri;
-        type Source = Set<members::source>;
-        type ViewerCount = St::ViewerCount;
     }
     ///State transition - sets the `viewer_count` field to Set
     pub struct SetViewerCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetViewerCount<St> {}
     impl<St: State> State for SetViewerCount<St> {
-        type StartsAt = St::StartsAt;
-        type TeleportUri = St::TeleportUri;
         type Source = St::Source;
+        type TeleportUri = St::TeleportUri;
         type ViewerCount = Set<members::viewer_count>;
+        type StartsAt = St::StartsAt;
+    }
+    ///State transition - sets the `starts_at` field to Set
+    pub struct SetStartsAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartsAt<St> {}
+    impl<St: State> State for SetStartsAt<St> {
+        type Source = St::Source;
+        type TeleportUri = St::TeleportUri;
+        type ViewerCount = St::ViewerCount;
+        type StartsAt = Set<members::starts_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `starts_at` field
-        pub struct starts_at(());
-        ///Marker type for the `teleport_uri` field
-        pub struct teleport_uri(());
         ///Marker type for the `source` field
         pub struct source(());
+        ///Marker type for the `teleport_uri` field
+        pub struct teleport_uri(());
         ///Marker type for the `viewer_count` field
         pub struct viewer_count(());
+        ///Marker type for the `starts_at` field
+        pub struct starts_at(());
     }
 }
 
@@ -1623,10 +1623,10 @@ where
 impl<S: BosStr, St> TeleportArrivalBuilder<S, St>
 where
     St: teleport_arrival_state::State,
-    St::StartsAt: teleport_arrival_state::IsSet,
-    St::TeleportUri: teleport_arrival_state::IsSet,
     St::Source: teleport_arrival_state::IsSet,
+    St::TeleportUri: teleport_arrival_state::IsSet,
     St::ViewerCount: teleport_arrival_state::IsSet,
+    St::StartsAt: teleport_arrival_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TeleportArrival<S> {
@@ -1665,37 +1665,37 @@ pub mod teleport_canceled_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TeleportUri;
         type Reason;
+        type TeleportUri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TeleportUri = Unset;
         type Reason = Unset;
-    }
-    ///State transition - sets the `teleport_uri` field to Set
-    pub struct SetTeleportUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTeleportUri<St> {}
-    impl<St: State> State for SetTeleportUri<St> {
-        type TeleportUri = Set<members::teleport_uri>;
-        type Reason = St::Reason;
+        type TeleportUri = Unset;
     }
     ///State transition - sets the `reason` field to Set
     pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReason<St> {}
     impl<St: State> State for SetReason<St> {
-        type TeleportUri = St::TeleportUri;
         type Reason = Set<members::reason>;
+        type TeleportUri = St::TeleportUri;
+    }
+    ///State transition - sets the `teleport_uri` field to Set
+    pub struct SetTeleportUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTeleportUri<St> {}
+    impl<St: State> State for SetTeleportUri<St> {
+        type Reason = St::Reason;
+        type TeleportUri = Set<members::teleport_uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `teleport_uri` field
-        pub struct teleport_uri(());
         ///Marker type for the `reason` field
         pub struct reason(());
+        ///Marker type for the `teleport_uri` field
+        pub struct teleport_uri(());
     }
 }
 
@@ -1765,8 +1765,8 @@ where
 impl<S: BosStr, St> TeleportCanceledBuilder<S, St>
 where
     St: teleport_canceled_state::State,
-    St::TeleportUri: teleport_canceled_state::IsSet,
     St::Reason: teleport_canceled_state::IsSet,
+    St::TeleportUri: teleport_canceled_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TeleportCanceled<S> {
diff --git a/crates/jacquard-api/src/place_stream/moderation.rs b/crates/jacquard-api/src/place_stream/moderation.rs
index 16b9c79b..b3fdd7c4 100644
--- a/crates/jacquard-api/src/place_stream/moderation.rs
+++ b/crates/jacquard-api/src/place_stream/moderation.rs
@@ -74,67 +74,67 @@ pub mod permission_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
-        type Author;
         type Cid;
+        type Uri;
         type Record;
+        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
-        type Author = Unset;
         type Cid = Unset;
+        type Uri = Unset;
         type Record = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Author = St::Author;
-        type Cid = St::Cid;
-        type Record = St::Record;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Uri = St::Uri;
-        type Author = Set<members::author>;
-        type Cid = St::Cid;
-        type Record = St::Record;
+        type Author = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
         type Uri = St::Uri;
+        type Record = St::Record;
         type Author = St::Author;
-        type Cid = Set<members::cid>;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
         type Record = St::Record;
+        type Author = St::Author;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
+        type Cid = St::Cid;
         type Uri = St::Uri;
+        type Record = Set<members::record>;
         type Author = St::Author;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
         type Cid = St::Cid;
-        type Record = Set<members::record>;
+        type Uri = St::Uri;
+        type Record = St::Record;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `author` field
+        pub struct author(());
     }
 }
 
@@ -247,10 +247,10 @@ where
 impl<S: BosStr, St> PermissionViewBuilder<S, St>
 where
     St: permission_view_state::State,
-    St::Uri: permission_view_state::IsSet,
-    St::Author: permission_view_state::IsSet,
     St::Cid: permission_view_state::IsSet,
+    St::Uri: permission_view_state::IsSet,
     St::Record: permission_view_state::IsSet,
+    St::Author: permission_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PermissionView<S> {
diff --git a/crates/jacquard-api/src/place_stream/moderation/delete_gate.rs b/crates/jacquard-api/src/place_stream/moderation/delete_gate.rs
index 2f236588..5dc23609 100644
--- a/crates/jacquard-api/src/place_stream/moderation/delete_gate.rs
+++ b/crates/jacquard-api/src/place_stream/moderation/delete_gate.rs
@@ -137,37 +137,37 @@ pub mod delete_gate_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Streamer;
         type GateUri;
+        type Streamer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Streamer = Unset;
         type GateUri = Unset;
-    }
-    ///State transition - sets the `streamer` field to Set
-    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStreamer<St> {}
-    impl<St: State> State for SetStreamer<St> {
-        type Streamer = Set<members::streamer>;
-        type GateUri = St::GateUri;
+        type Streamer = Unset;
     }
     ///State transition - sets the `gate_uri` field to Set
     pub struct SetGateUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGateUri<St> {}
     impl<St: State> State for SetGateUri<St> {
-        type Streamer = St::Streamer;
         type GateUri = Set<members::gate_uri>;
+        type Streamer = St::Streamer;
+    }
+    ///State transition - sets the `streamer` field to Set
+    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStreamer<St> {}
+    impl<St: State> State for SetStreamer<St> {
+        type GateUri = St::GateUri;
+        type Streamer = Set<members::streamer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `gate_uri` field
         pub struct gate_uri(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
     }
 }
 
@@ -237,8 +237,8 @@ where
 impl<S: BosStr, St> DeleteGateBuilder<S, St>
 where
     St: delete_gate_state::State,
-    St::Streamer: delete_gate_state::IsSet,
     St::GateUri: delete_gate_state::IsSet,
+    St::Streamer: delete_gate_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeleteGate<S> {
diff --git a/crates/jacquard-api/src/place_stream/moderation/permission.rs b/crates/jacquard-api/src/place_stream/moderation/permission.rs
index 25c1dde7..04cee61a 100644
--- a/crates/jacquard-api/src/place_stream/moderation/permission.rs
+++ b/crates/jacquard-api/src/place_stream/moderation/permission.rs
@@ -119,51 +119,51 @@ pub mod permission_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Permissions;
-        type Moderator;
         type CreatedAt;
+        type Moderator;
+        type Permissions;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Permissions = Unset;
-        type Moderator = Unset;
         type CreatedAt = Unset;
+        type Moderator = Unset;
+        type Permissions = Unset;
     }
-    ///State transition - sets the `permissions` field to Set
-    pub struct SetPermissions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPermissions<St> {}
-    impl<St: State> State for SetPermissions<St> {
-        type Permissions = Set<members::permissions>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Moderator = St::Moderator;
-        type CreatedAt = St::CreatedAt;
+        type Permissions = St::Permissions;
     }
     ///State transition - sets the `moderator` field to Set
     pub struct SetModerator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetModerator<St> {}
     impl<St: State> State for SetModerator<St> {
-        type Permissions = St::Permissions;
-        type Moderator = Set<members::moderator>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Moderator = Set<members::moderator>;
         type Permissions = St::Permissions;
+    }
+    ///State transition - sets the `permissions` field to Set
+    pub struct SetPermissions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPermissions<St> {}
+    impl<St: State> State for SetPermissions<St> {
+        type CreatedAt = St::CreatedAt;
         type Moderator = St::Moderator;
-        type CreatedAt = Set<members::created_at>;
+        type Permissions = Set<members::permissions>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `permissions` field
-        pub struct permissions(());
-        ///Marker type for the `moderator` field
-        pub struct moderator(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `moderator` field
+        pub struct moderator(());
+        ///Marker type for the `permissions` field
+        pub struct permissions(());
     }
 }
 
@@ -265,9 +265,9 @@ where
 impl<S: BosStr, St> PermissionBuilder<S, St>
 where
     St: permission_state::State,
-    St::Permissions: permission_state::IsSet,
-    St::Moderator: permission_state::IsSet,
     St::CreatedAt: permission_state::IsSet,
+    St::Moderator: permission_state::IsSet,
+    St::Permissions: permission_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Permission<S> {
diff --git a/crates/jacquard-api/src/place_stream/moderation/update_livestream.rs b/crates/jacquard-api/src/place_stream/moderation/update_livestream.rs
index 8921a812..8e116707 100644
--- a/crates/jacquard-api/src/place_stream/moderation/update_livestream.rs
+++ b/crates/jacquard-api/src/place_stream/moderation/update_livestream.rs
@@ -154,37 +154,37 @@ pub mod update_livestream_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Streamer;
         type LivestreamUri;
+        type Streamer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Streamer = Unset;
         type LivestreamUri = Unset;
-    }
-    ///State transition - sets the `streamer` field to Set
-    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStreamer<St> {}
-    impl<St: State> State for SetStreamer<St> {
-        type Streamer = Set<members::streamer>;
-        type LivestreamUri = St::LivestreamUri;
+        type Streamer = Unset;
     }
     ///State transition - sets the `livestream_uri` field to Set
     pub struct SetLivestreamUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLivestreamUri<St> {}
     impl<St: State> State for SetLivestreamUri<St> {
-        type Streamer = St::Streamer;
         type LivestreamUri = Set<members::livestream_uri>;
+        type Streamer = St::Streamer;
+    }
+    ///State transition - sets the `streamer` field to Set
+    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStreamer<St> {}
+    impl<St: State> State for SetStreamer<St> {
+        type LivestreamUri = St::LivestreamUri;
+        type Streamer = Set<members::streamer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `livestream_uri` field
         pub struct livestream_uri(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
     }
 }
 
@@ -267,8 +267,8 @@ impl<S: BosStr, St: update_livestream_state::State> UpdateLivestreamBuilder<S, S
 impl<S: BosStr, St> UpdateLivestreamBuilder<S, St>
 where
     St: update_livestream_state::State,
-    St::Streamer: update_livestream_state::IsSet,
     St::LivestreamUri: update_livestream_state::IsSet,
+    St::Streamer: update_livestream_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateLivestream<S> {
diff --git a/crates/jacquard-api/src/place_stream/multistream.rs b/crates/jacquard-api/src/place_stream/multistream.rs
index 3a25d541..e087ffd4 100644
--- a/crates/jacquard-api/src/place_stream/multistream.rs
+++ b/crates/jacquard-api/src/place_stream/multistream.rs
@@ -96,51 +96,51 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Message;
-        type Status;
         type CreatedAt;
+        type Status;
+        type Message;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Message = Unset;
-        type Status = Unset;
         type CreatedAt = Unset;
+        type Status = Unset;
+        type Message = Unset;
     }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
-        type Message = Set<members::message>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Status = St::Status;
-        type CreatedAt = St::CreatedAt;
+        type Message = St::Message;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type Message = St::Message;
-        type Status = Set<members::status>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Status = Set<members::status>;
         type Message = St::Message;
+    }
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type CreatedAt = St::CreatedAt;
         type Status = St::Status;
-        type CreatedAt = Set<members::created_at>;
+        type Message = Set<members::message>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `message` field
-        pub struct message(());
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `status` field
+        pub struct status(());
+        ///Marker type for the `message` field
+        pub struct message(());
     }
 }
 
@@ -229,9 +229,9 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::Message: event_state::IsSet,
-    St::Status: event_state::IsSet,
     St::CreatedAt: event_state::IsSet,
+    St::Status: event_state::IsSet,
+    St::Message: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
@@ -358,51 +358,51 @@ pub mod target_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
-        type Record;
         type Cid;
+        type Record;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
-        type Record = Unset;
         type Cid = Unset;
+        type Record = Unset;
+        type Uri = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
         type Record = St::Record;
-        type Cid = St::Cid;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Uri = St::Uri;
-        type Record = Set<members::record>;
         type Cid = St::Cid;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+        type Record = Set<members::record>;
         type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
         type Record = St::Record;
-        type Cid = Set<members::cid>;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `record` field
-        pub struct record(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `record` field
+        pub struct record(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -512,9 +512,9 @@ where
 impl<S: BosStr, St> TargetViewBuilder<S, St>
 where
     St: target_view_state::State,
-    St::Uri: target_view_state::IsSet,
-    St::Record: target_view_state::IsSet,
     St::Cid: target_view_state::IsSet,
+    St::Record: target_view_state::IsSet,
+    St::Uri: target_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TargetView<S> {
diff --git a/crates/jacquard-api/src/place_stream/multistream/list_targets.rs b/crates/jacquard-api/src/place_stream/multistream/list_targets.rs
index 45d3d539..68165a6b 100644
--- a/crates/jacquard-api/src/place_stream/multistream/list_targets.rs
+++ b/crates/jacquard-api/src/place_stream/multistream/list_targets.rs
@@ -195,49 +195,49 @@ pub mod record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
         type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
+        type Cid = Unset;
         type Value = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
-        type Value = St::Value;
-    }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Value = St::Value;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Cid = St::Cid;
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `value` field
         pub struct value(());
     }
@@ -328,8 +328,8 @@ where
 impl<S: BosStr, St> RecordBuilder<S, St>
 where
     St: record_state::State,
-    St::Cid: record_state::IsSet,
     St::Uri: record_state::IsSet,
+    St::Cid: record_state::IsSet,
     St::Value: record_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/place_stream/multistream/target.rs b/crates/jacquard-api/src/place_stream/multistream/target.rs
index 6e933b28..bbdc7dde 100644
--- a/crates/jacquard-api/src/place_stream/multistream/target.rs
+++ b/crates/jacquard-api/src/place_stream/multistream/target.rs
@@ -129,51 +129,51 @@ pub mod target_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Url;
         type Active;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Url = Unset;
         type Active = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Url = St::Url;
+        type Active = St::Active;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
+        type CreatedAt = St::CreatedAt;
         type Url = Set<members::url>;
         type Active = St::Active;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `active` field to Set
     pub struct SetActive<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActive<St> {}
     impl<St: State> State for SetActive<St> {
-        type Url = St::Url;
-        type Active = Set<members::active>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Url = St::Url;
-        type Active = St::Active;
-        type CreatedAt = Set<members::created_at>;
+        type Active = Set<members::active>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `url` field
         pub struct url(());
         ///Marker type for the `active` field
         pub struct active(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -275,9 +275,9 @@ where
 impl<S: BosStr, St> TargetBuilder<S, St>
 where
     St: target_state::State,
+    St::CreatedAt: target_state::IsSet,
     St::Url: target_state::IsSet,
     St::Active: target_state::IsSet,
-    St::CreatedAt: target_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Target<S> {
diff --git a/crates/jacquard-api/src/place_stream/playback/whep.rs b/crates/jacquard-api/src/place_stream/playback/whep.rs
index 2eb7031f..99193826 100644
--- a/crates/jacquard-api/src/place_stream/playback/whep.rs
+++ b/crates/jacquard-api/src/place_stream/playback/whep.rs
@@ -117,7 +117,7 @@ impl jacquard_common::xrpc::XrpcRequest for Whep {
     type Response = WhepResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
@@ -157,37 +157,37 @@ pub mod whep_params_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Streamer;
         type Rendition;
+        type Streamer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Streamer = Unset;
         type Rendition = Unset;
-    }
-    ///State transition - sets the `streamer` field to Set
-    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStreamer<St> {}
-    impl<St: State> State for SetStreamer<St> {
-        type Streamer = Set<members::streamer>;
-        type Rendition = St::Rendition;
+        type Streamer = Unset;
     }
     ///State transition - sets the `rendition` field to Set
     pub struct SetRendition<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRendition<St> {}
     impl<St: State> State for SetRendition<St> {
-        type Streamer = St::Streamer;
         type Rendition = Set<members::rendition>;
+        type Streamer = St::Streamer;
+    }
+    ///State transition - sets the `streamer` field to Set
+    pub struct SetStreamer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStreamer<St> {}
+    impl<St: State> State for SetStreamer<St> {
+        type Rendition = St::Rendition;
+        type Streamer = Set<members::streamer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `streamer` field
-        pub struct streamer(());
         ///Marker type for the `rendition` field
         pub struct rendition(());
+        ///Marker type for the `streamer` field
+        pub struct streamer(());
     }
 }
 
@@ -257,8 +257,8 @@ where
 impl<S: BosStr, St> WhepParamsBuilder<S, St>
 where
     St: whep_params_state::State,
-    St::Streamer: whep_params_state::IsSet,
     St::Rendition: whep_params_state::IsSet,
+    St::Streamer: whep_params_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> WhepParams<S> {
diff --git a/crates/jacquard-api/src/place_stream/richtext/facet.rs b/crates/jacquard-api/src/place_stream/richtext/facet.rs
index a469b1e7..ad1c2cd1 100644
--- a/crates/jacquard-api/src/place_stream/richtext/facet.rs
+++ b/crates/jacquard-api/src/place_stream/richtext/facet.rs
@@ -73,37 +73,37 @@ pub mod facet_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Features;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Features = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Features = St::Features;
+        type Index = Unset;
     }
     ///State transition - sets the `features` field to Set
     pub struct SetFeatures<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFeatures<St> {}
     impl<St: State> State for SetFeatures<St> {
-        type Index = St::Index;
         type Features = Set<members::features>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Features = St::Features;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `features` field
         pub struct features(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -173,8 +173,8 @@ where
 impl<S: BosStr, St> FacetBuilder<S, St>
 where
     St: facet_state::State,
-    St::Index: facet_state::IsSet,
     St::Features: facet_state::IsSet,
+    St::Index: facet_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Facet<S> {
diff --git a/crates/jacquard-api/src/place_stream/segment.rs b/crates/jacquard-api/src/place_stream/segment.rs
index 63cab9df..068a5a71 100644
--- a/crates/jacquard-api/src/place_stream/segment.rs
+++ b/crates/jacquard-api/src/place_stream/segment.rs
@@ -243,51 +243,51 @@ pub mod audio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Channels;
         type Codec;
         type Rate;
+        type Channels;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Channels = Unset;
         type Codec = Unset;
         type Rate = Unset;
-    }
-    ///State transition - sets the `channels` field to Set
-    pub struct SetChannels<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChannels<St> {}
-    impl<St: State> State for SetChannels<St> {
-        type Channels = Set<members::channels>;
-        type Codec = St::Codec;
-        type Rate = St::Rate;
+        type Channels = Unset;
     }
     ///State transition - sets the `codec` field to Set
     pub struct SetCodec<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCodec<St> {}
     impl<St: State> State for SetCodec<St> {
-        type Channels = St::Channels;
         type Codec = Set<members::codec>;
         type Rate = St::Rate;
+        type Channels = St::Channels;
     }
     ///State transition - sets the `rate` field to Set
     pub struct SetRate<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRate<St> {}
     impl<St: State> State for SetRate<St> {
-        type Channels = St::Channels;
         type Codec = St::Codec;
         type Rate = Set<members::rate>;
+        type Channels = St::Channels;
+    }
+    ///State transition - sets the `channels` field to Set
+    pub struct SetChannels<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChannels<St> {}
+    impl<St: State> State for SetChannels<St> {
+        type Codec = St::Codec;
+        type Rate = St::Rate;
+        type Channels = Set<members::channels>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `channels` field
-        pub struct channels(());
         ///Marker type for the `codec` field
         pub struct codec(());
         ///Marker type for the `rate` field
         pub struct rate(());
+        ///Marker type for the `channels` field
+        pub struct channels(());
     }
 }
 
@@ -376,9 +376,9 @@ where
 impl<S: BosStr, St> AudioBuilder<S, St>
 where
     St: audio_state::State,
-    St::Channels: audio_state::IsSet,
     St::Codec: audio_state::IsSet,
     St::Rate: audio_state::IsSet,
+    St::Channels: audio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Audio<S> {
@@ -1281,49 +1281,49 @@ pub mod video_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
         type Codec;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
+        type Width = Unset;
         type Codec = Unset;
     }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
-        type Codec = St::Codec;
-    }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+        type Codec = St::Codec;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
         type Codec = St::Codec;
     }
     ///State transition - sets the `codec` field to Set
     pub struct SetCodec<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCodec<St> {}
     impl<St: State> State for SetCodec<St> {
-        type Width = St::Width;
         type Height = St::Height;
+        type Width = St::Width;
         type Codec = Set<members::codec>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
         ///Marker type for the `codec` field
         pub struct codec(());
     }
@@ -1446,8 +1446,8 @@ where
 impl<S: BosStr, St> VideoBuilder<S, St>
 where
     St: video_state::State,
-    St::Width: video_state::IsSet,
     St::Height: video_state::IsSet,
+    St::Width: video_state::IsSet,
     St::Codec: video_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/place_stream/server.rs b/crates/jacquard-api/src/place_stream/server.rs
index 35efa552..eb1b24df 100644
--- a/crates/jacquard-api/src/place_stream/server.rs
+++ b/crates/jacquard-api/src/place_stream/server.rs
@@ -428,85 +428,85 @@ pub mod webhook_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Id;
         type Active;
-        type Url;
+        type Id;
         type CreatedAt;
         type Events;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Id = Unset;
         type Active = Unset;
-        type Url = Unset;
+        type Id = Unset;
         type CreatedAt = Unset;
         type Events = Unset;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
-        type Active = St::Active;
-        type Url = St::Url;
-        type CreatedAt = St::CreatedAt;
-        type Events = St::Events;
+        type Url = Unset;
     }
     ///State transition - sets the `active` field to Set
     pub struct SetActive<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActive<St> {}
     impl<St: State> State for SetActive<St> {
-        type Id = St::Id;
         type Active = Set<members::active>;
-        type Url = St::Url;
+        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
         type Events = St::Events;
+        type Url = St::Url;
     }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Id = St::Id;
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
         type Active = St::Active;
-        type Url = Set<members::url>;
+        type Id = Set<members::id>;
         type CreatedAt = St::CreatedAt;
         type Events = St::Events;
+        type Url = St::Url;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Id = St::Id;
         type Active = St::Active;
-        type Url = St::Url;
+        type Id = St::Id;
         type CreatedAt = Set<members::created_at>;
         type Events = St::Events;
+        type Url = St::Url;
     }
     ///State transition - sets the `events` field to Set
     pub struct SetEvents<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvents<St> {}
     impl<St: State> State for SetEvents<St> {
-        type Id = St::Id;
         type Active = St::Active;
-        type Url = St::Url;
+        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
         type Events = Set<members::events>;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Active = St::Active;
+        type Id = St::Id;
+        type CreatedAt = St::CreatedAt;
+        type Events = St::Events;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `active` field
         pub struct active(());
-        ///Marker type for the `url` field
-        pub struct url(());
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `events` field
         pub struct events(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -783,11 +783,11 @@ where
 impl<S: BosStr, St> WebhookBuilder<S, St>
 where
     St: webhook_state::State,
-    St::Id: webhook_state::IsSet,
     St::Active: webhook_state::IsSet,
-    St::Url: webhook_state::IsSet,
+    St::Id: webhook_state::IsSet,
     St::CreatedAt: webhook_state::IsSet,
     St::Events: webhook_state::IsSet,
+    St::Url: webhook_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Webhook<S> {
diff --git a/crates/jacquard-api/src/place_stream/server/create_webhook.rs b/crates/jacquard-api/src/place_stream/server/create_webhook.rs
index b7bd6ffd..50cc2c33 100644
--- a/crates/jacquard-api/src/place_stream/server/create_webhook.rs
+++ b/crates/jacquard-api/src/place_stream/server/create_webhook.rs
@@ -166,37 +166,37 @@ pub mod create_webhook_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Url;
         type Events;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Url = Unset;
         type Events = Unset;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Url = Set<members::url>;
-        type Events = St::Events;
+        type Url = Unset;
     }
     ///State transition - sets the `events` field to Set
     pub struct SetEvents<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvents<St> {}
     impl<St: State> State for SetEvents<St> {
-        type Url = St::Url;
         type Events = Set<members::events>;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Events = St::Events;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `events` field
         pub struct events(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -367,8 +367,8 @@ where
 impl<S: BosStr, St> CreateWebhookBuilder<S, St>
 where
     St: create_webhook_state::State,
-    St::Url: create_webhook_state::IsSet,
     St::Events: create_webhook_state::IsSet,
+    St::Url: create_webhook_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CreateWebhook<S> {
diff --git a/crates/jacquard-api/src/place_wisp/fs.rs b/crates/jacquard-api/src/place_wisp/fs.rs
index 7e4ff68e..c648760b 100644
--- a/crates/jacquard-api/src/place_wisp/fs.rs
+++ b/crates/jacquard-api/src/place_wisp/fs.rs
@@ -977,49 +977,49 @@ pub mod fs_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Site;
+        type CreatedAt;
         type Root;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Site = Unset;
+        type CreatedAt = Unset;
         type Root = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Site = St::Site;
-        type Root = St::Root;
-    }
     ///State transition - sets the `site` field to Set
     pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSite<St> {}
     impl<St: State> State for SetSite<St> {
-        type CreatedAt = St::CreatedAt;
         type Site = Set<members::site>;
+        type CreatedAt = St::CreatedAt;
+        type Root = St::Root;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Site = St::Site;
+        type CreatedAt = Set<members::created_at>;
         type Root = St::Root;
     }
     ///State transition - sets the `root` field to Set
     pub struct SetRoot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRoot<St> {}
     impl<St: State> State for SetRoot<St> {
-        type CreatedAt = St::CreatedAt;
         type Site = St::Site;
+        type CreatedAt = St::CreatedAt;
         type Root = Set<members::root>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `site` field
         pub struct site(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `root` field
         pub struct root(());
     }
@@ -1120,8 +1120,8 @@ where
 impl<S: BosStr, St> FsBuilder<S, St>
 where
     St: fs_state::State,
-    St::CreatedAt: fs_state::IsSet,
     St::Site: fs_state::IsSet,
+    St::CreatedAt: fs_state::IsSet,
     St::Root: fs_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/pub_leaflet/comment.rs b/crates/jacquard-api/src/pub_leaflet/comment.rs
index e3885702..ea8a843f 100644
--- a/crates/jacquard-api/src/pub_leaflet/comment.rs
+++ b/crates/jacquard-api/src/pub_leaflet/comment.rs
@@ -173,37 +173,37 @@ pub mod linear_document_quote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Document;
         type Quote;
+        type Document;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Document = Unset;
         type Quote = Unset;
-    }
-    ///State transition - sets the `document` field to Set
-    pub struct SetDocument<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDocument<St> {}
-    impl<St: State> State for SetDocument<St> {
-        type Document = Set<members::document>;
-        type Quote = St::Quote;
+        type Document = Unset;
     }
     ///State transition - sets the `quote` field to Set
     pub struct SetQuote<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetQuote<St> {}
     impl<St: State> State for SetQuote<St> {
-        type Document = St::Document;
         type Quote = Set<members::quote>;
+        type Document = St::Document;
+    }
+    ///State transition - sets the `document` field to Set
+    pub struct SetDocument<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDocument<St> {}
+    impl<St: State> State for SetDocument<St> {
+        type Quote = St::Quote;
+        type Document = Set<members::document>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `document` field
-        pub struct document(());
         ///Marker type for the `quote` field
         pub struct quote(());
+        ///Marker type for the `document` field
+        pub struct document(());
     }
 }
 
@@ -276,8 +276,8 @@ where
 impl<S: BosStr, St> LinearDocumentQuoteBuilder<S, St>
 where
     St: linear_document_quote_state::State,
-    St::Document: linear_document_quote_state::IsSet,
     St::Quote: linear_document_quote_state::IsSet,
+    St::Document: linear_document_quote_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LinearDocumentQuote<S> {
@@ -450,51 +450,51 @@ pub mod comment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Plaintext;
         type Subject;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Plaintext = Unset;
         type Subject = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Plaintext = St::Plaintext;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `plaintext` field to Set
     pub struct SetPlaintext<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPlaintext<St> {}
     impl<St: State> State for SetPlaintext<St> {
+        type CreatedAt = St::CreatedAt;
         type Plaintext = Set<members::plaintext>;
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Plaintext = St::Plaintext;
-        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Plaintext = St::Plaintext;
-        type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `plaintext` field
         pub struct plaintext(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -649,9 +649,9 @@ where
 impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
+    St::CreatedAt: comment_state::IsSet,
     St::Plaintext: comment_state::IsSet,
     St::Subject: comment_state::IsSet,
-    St::CreatedAt: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/pub_leaflet/document.rs b/crates/jacquard-api/src/pub_leaflet/document.rs
index 38dcb149..b507afb4 100644
--- a/crates/jacquard-api/src/pub_leaflet/document.rs
+++ b/crates/jacquard-api/src/pub_leaflet/document.rs
@@ -234,51 +234,51 @@ pub mod document_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Title;
         type Pages;
         type Author;
-        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Title = Unset;
         type Pages = Unset;
         type Author = Unset;
-        type Title = Unset;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
+        type Pages = St::Pages;
+        type Author = St::Author;
     }
     ///State transition - sets the `pages` field to Set
     pub struct SetPages<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPages<St> {}
     impl<St: State> State for SetPages<St> {
+        type Title = St::Title;
         type Pages = Set<members::pages>;
         type Author = St::Author;
-        type Title = St::Title;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Pages = St::Pages;
-        type Author = Set<members::author>;
         type Title = St::Title;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
         type Pages = St::Pages;
-        type Author = St::Author;
-        type Title = Set<members::title>;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `pages` field
         pub struct pages(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `title` field
-        pub struct title(());
     }
 }
 
@@ -483,9 +483,9 @@ where
 impl<S: BosStr, St> DocumentBuilder<S, St>
 where
     St: document_state::State,
+    St::Title: document_state::IsSet,
     St::Pages: document_state::IsSet,
     St::Author: document_state::IsSet,
-    St::Title: document_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Document<S> {
diff --git a/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs b/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs
index 6b95ea29..cdb5a9a7 100644
--- a/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs
+++ b/crates/jacquard-api/src/pub_leaflet/pages/canvas.rs
@@ -222,66 +222,66 @@ pub mod block_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Width;
-        type Y;
-        type Block;
         type X;
+        type Block;
+        type Y;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Width = Unset;
-        type Y = Unset;
-        type Block = Unset;
         type X = Unset;
+        type Block = Unset;
+        type Y = Unset;
     }
     ///State transition - sets the `width` field to Set
     pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidth<St> {}
     impl<St: State> State for SetWidth<St> {
         type Width = Set<members::width>;
-        type Y = St::Y;
-        type Block = St::Block;
         type X = St::X;
+        type Block = St::Block;
+        type Y = St::Y;
     }
-    ///State transition - sets the `y` field to Set
-    pub struct SetY<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetY<St> {}
-    impl<St: State> State for SetY<St> {
+    ///State transition - sets the `x` field to Set
+    pub struct SetX<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetX<St> {}
+    impl<St: State> State for SetX<St> {
         type Width = St::Width;
-        type Y = Set<members::y>;
+        type X = Set<members::x>;
         type Block = St::Block;
-        type X = St::X;
+        type Y = St::Y;
     }
     ///State transition - sets the `block` field to Set
     pub struct SetBlock<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlock<St> {}
     impl<St: State> State for SetBlock<St> {
         type Width = St::Width;
-        type Y = St::Y;
-        type Block = Set<members::block>;
         type X = St::X;
+        type Block = Set<members::block>;
+        type Y = St::Y;
     }
-    ///State transition - sets the `x` field to Set
-    pub struct SetX<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetX<St> {}
-    impl<St: State> State for SetX<St> {
+    ///State transition - sets the `y` field to Set
+    pub struct SetY<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetY<St> {}
+    impl<St: State> State for SetY<St> {
         type Width = St::Width;
-        type Y = St::Y;
+        type X = St::X;
         type Block = St::Block;
-        type X = Set<members::x>;
+        type Y = Set<members::y>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `width` field
         pub struct width(());
-        ///Marker type for the `y` field
-        pub struct y(());
-        ///Marker type for the `block` field
-        pub struct block(());
         ///Marker type for the `x` field
         pub struct x(());
+        ///Marker type for the `block` field
+        pub struct block(());
+        ///Marker type for the `y` field
+        pub struct y(());
     }
 }
 
@@ -417,9 +417,9 @@ impl<S: BosStr, St> BlockBuilder<S, St>
 where
     St: block_state::State,
     St::Width: block_state::IsSet,
-    St::Y: block_state::IsSet,
-    St::Block: block_state::IsSet,
     St::X: block_state::IsSet,
+    St::Block: block_state::IsSet,
+    St::Y: block_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Block<S> {
@@ -750,37 +750,37 @@ pub mod position_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Offset;
         type Block;
+        type Offset;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Offset = Unset;
         type Block = Unset;
-    }
-    ///State transition - sets the `offset` field to Set
-    pub struct SetOffset<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOffset<St> {}
-    impl<St: State> State for SetOffset<St> {
-        type Offset = Set<members::offset>;
-        type Block = St::Block;
+        type Offset = Unset;
     }
     ///State transition - sets the `block` field to Set
     pub struct SetBlock<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlock<St> {}
     impl<St: State> State for SetBlock<St> {
-        type Offset = St::Offset;
         type Block = Set<members::block>;
+        type Offset = St::Offset;
+    }
+    ///State transition - sets the `offset` field to Set
+    pub struct SetOffset<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOffset<St> {}
+    impl<St: State> State for SetOffset<St> {
+        type Block = St::Block;
+        type Offset = Set<members::offset>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `offset` field
-        pub struct offset(());
         ///Marker type for the `block` field
         pub struct block(());
+        ///Marker type for the `offset` field
+        pub struct offset(());
     }
 }
 
@@ -850,8 +850,8 @@ where
 impl<S: BosStr, St> PositionBuilder<S, St>
 where
     St: position_state::State,
-    St::Offset: position_state::IsSet,
     St::Block: position_state::IsSet,
+    St::Offset: position_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Position<S> {
diff --git a/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs b/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs
index 6dc3ba93..fcdb8833 100644
--- a/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs
+++ b/crates/jacquard-api/src/pub_leaflet/pages/linear_document.rs
@@ -691,37 +691,37 @@ pub mod position_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Block;
         type Offset;
+        type Block;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Block = Unset;
         type Offset = Unset;
-    }
-    ///State transition - sets the `block` field to Set
-    pub struct SetBlock<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlock<St> {}
-    impl<St: State> State for SetBlock<St> {
-        type Block = Set<members::block>;
-        type Offset = St::Offset;
+        type Block = Unset;
     }
     ///State transition - sets the `offset` field to Set
     pub struct SetOffset<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOffset<St> {}
     impl<St: State> State for SetOffset<St> {
-        type Block = St::Block;
         type Offset = Set<members::offset>;
+        type Block = St::Block;
+    }
+    ///State transition - sets the `block` field to Set
+    pub struct SetBlock<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlock<St> {}
+    impl<St: State> State for SetBlock<St> {
+        type Offset = St::Offset;
+        type Block = Set<members::block>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `block` field
-        pub struct block(());
         ///Marker type for the `offset` field
         pub struct offset(());
+        ///Marker type for the `block` field
+        pub struct block(());
     }
 }
 
@@ -791,8 +791,8 @@ where
 impl<S: BosStr, St> PositionBuilder<S, St>
 where
     St: position_state::State,
-    St::Block: position_state::IsSet,
     St::Offset: position_state::IsSet,
+    St::Block: position_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Position<S> {
@@ -822,37 +822,37 @@ pub mod quote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type End;
         type Start;
+        type End;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type End = Unset;
         type Start = Unset;
-    }
-    ///State transition - sets the `end` field to Set
-    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEnd<St> {}
-    impl<St: State> State for SetEnd<St> {
-        type End = Set<members::end>;
-        type Start = St::Start;
+        type End = Unset;
     }
     ///State transition - sets the `start` field to Set
     pub struct SetStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStart<St> {}
     impl<St: State> State for SetStart<St> {
-        type End = St::End;
         type Start = Set<members::start>;
+        type End = St::End;
+    }
+    ///State transition - sets the `end` field to Set
+    pub struct SetEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEnd<St> {}
+    impl<St: State> State for SetEnd<St> {
+        type Start = St::Start;
+        type End = Set<members::end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `end` field
-        pub struct end(());
         ///Marker type for the `start` field
         pub struct start(());
+        ///Marker type for the `end` field
+        pub struct end(());
     }
 }
 
@@ -925,8 +925,8 @@ where
 impl<S: BosStr, St> QuoteBuilder<S, St>
 where
     St: quote_state::State,
-    St::End: quote_state::IsSet,
     St::Start: quote_state::IsSet,
+    St::End: quote_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Quote<S> {
diff --git a/crates/jacquard-api/src/pub_leaflet/poll/definition.rs b/crates/jacquard-api/src/pub_leaflet/poll/definition.rs
index f5b46f9b..59794f32 100644
--- a/crates/jacquard-api/src/pub_leaflet/poll/definition.rs
+++ b/crates/jacquard-api/src/pub_leaflet/poll/definition.rs
@@ -186,37 +186,37 @@ pub mod definition_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Options;
         type Name;
+        type Options;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Options = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `options` field to Set
-    pub struct SetOptions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOptions<St> {}
-    impl<St: State> State for SetOptions<St> {
-        type Options = Set<members::options>;
-        type Name = St::Name;
+        type Options = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Options = St::Options;
         type Name = Set<members::name>;
+        type Options = St::Options;
+    }
+    ///State transition - sets the `options` field to Set
+    pub struct SetOptions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOptions<St> {}
+    impl<St: State> State for SetOptions<St> {
+        type Name = St::Name;
+        type Options = Set<members::options>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `options` field
-        pub struct options(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `options` field
+        pub struct options(());
     }
 }
 
@@ -299,8 +299,8 @@ where
 impl<S: BosStr, St> DefinitionBuilder<S, St>
 where
     St: definition_state::State,
-    St::Options: definition_state::IsSet,
     St::Name: definition_state::IsSet,
+    St::Options: definition_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Definition<S> {
diff --git a/crates/jacquard-api/src/pub_leaflet/theme/color.rs b/crates/jacquard-api/src/pub_leaflet/theme/color.rs
index e37ebd57..915a9167 100644
--- a/crates/jacquard-api/src/pub_leaflet/theme/color.rs
+++ b/crates/jacquard-api/src/pub_leaflet/theme/color.rs
@@ -226,51 +226,51 @@ pub mod rgb_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type R;
         type G;
         type B;
-        type R;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type R = Unset;
         type G = Unset;
         type B = Unset;
-        type R = Unset;
+    }
+    ///State transition - sets the `r` field to Set
+    pub struct SetR<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetR<St> {}
+    impl<St: State> State for SetR<St> {
+        type R = Set<members::r>;
+        type G = St::G;
+        type B = St::B;
     }
     ///State transition - sets the `g` field to Set
     pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetG<St> {}
     impl<St: State> State for SetG<St> {
+        type R = St::R;
         type G = Set<members::g>;
         type B = St::B;
-        type R = St::R;
     }
     ///State transition - sets the `b` field to Set
     pub struct SetB<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetB<St> {}
     impl<St: State> State for SetB<St> {
-        type G = St::G;
-        type B = Set<members::b>;
         type R = St::R;
-    }
-    ///State transition - sets the `r` field to Set
-    pub struct SetR<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetR<St> {}
-    impl<St: State> State for SetR<St> {
         type G = St::G;
-        type B = St::B;
-        type R = Set<members::r>;
+        type B = Set<members::b>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `r` field
+        pub struct r(());
         ///Marker type for the `g` field
         pub struct g(());
         ///Marker type for the `b` field
         pub struct b(());
-        ///Marker type for the `r` field
-        pub struct r(());
     }
 }
 
@@ -350,9 +350,9 @@ where
 impl<S: BosStr, St> RgbBuilder<S, St>
 where
     St: rgb_state::State,
+    St::R: rgb_state::IsSet,
     St::G: rgb_state::IsSet,
     St::B: rgb_state::IsSet,
-    St::R: rgb_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rgb<S> {
@@ -490,67 +490,67 @@ pub mod rgba_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type G;
-        type A;
         type R;
         type B;
+        type G;
+        type A;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type G = Unset;
-        type A = Unset;
         type R = Unset;
         type B = Unset;
-    }
-    ///State transition - sets the `g` field to Set
-    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetG<St> {}
-    impl<St: State> State for SetG<St> {
-        type G = Set<members::g>;
-        type A = St::A;
-        type R = St::R;
-        type B = St::B;
-    }
-    ///State transition - sets the `a` field to Set
-    pub struct SetA<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetA<St> {}
-    impl<St: State> State for SetA<St> {
-        type G = St::G;
-        type A = Set<members::a>;
-        type R = St::R;
-        type B = St::B;
+        type G = Unset;
+        type A = Unset;
     }
     ///State transition - sets the `r` field to Set
     pub struct SetR<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetR<St> {}
     impl<St: State> State for SetR<St> {
-        type G = St::G;
-        type A = St::A;
         type R = Set<members::r>;
         type B = St::B;
+        type G = St::G;
+        type A = St::A;
     }
     ///State transition - sets the `b` field to Set
     pub struct SetB<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetB<St> {}
     impl<St: State> State for SetB<St> {
+        type R = St::R;
+        type B = Set<members::b>;
         type G = St::G;
         type A = St::A;
+    }
+    ///State transition - sets the `g` field to Set
+    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetG<St> {}
+    impl<St: State> State for SetG<St> {
         type R = St::R;
-        type B = Set<members::b>;
+        type B = St::B;
+        type G = Set<members::g>;
+        type A = St::A;
+    }
+    ///State transition - sets the `a` field to Set
+    pub struct SetA<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetA<St> {}
+    impl<St: State> State for SetA<St> {
+        type R = St::R;
+        type B = St::B;
+        type G = St::G;
+        type A = Set<members::a>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `g` field
-        pub struct g(());
-        ///Marker type for the `a` field
-        pub struct a(());
         ///Marker type for the `r` field
         pub struct r(());
         ///Marker type for the `b` field
         pub struct b(());
+        ///Marker type for the `g` field
+        pub struct g(());
+        ///Marker type for the `a` field
+        pub struct a(());
     }
 }
 
@@ -646,10 +646,10 @@ where
 impl<S: BosStr, St> RgbaBuilder<S, St>
 where
     St: rgba_state::State,
-    St::G: rgba_state::IsSet,
-    St::A: rgba_state::IsSet,
     St::R: rgba_state::IsSet,
     St::B: rgba_state::IsSet,
+    St::G: rgba_state::IsSet,
+    St::A: rgba_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rgba<S> {
diff --git a/crates/jacquard-api/src/pub_quizzy/answer.rs b/crates/jacquard-api/src/pub_quizzy/answer.rs
index 37c87450..4a9aef2e 100644
--- a/crates/jacquard-api/src/pub_quizzy/answer.rs
+++ b/crates/jacquard-api/src/pub_quizzy/answer.rs
@@ -230,67 +230,67 @@ pub mod answer_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Question;
-        type Certainty;
         type Timestamp;
+        type Question;
         type Text;
+        type Certainty;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Question = Unset;
-        type Certainty = Unset;
         type Timestamp = Unset;
+        type Question = Unset;
         type Text = Unset;
-    }
-    ///State transition - sets the `question` field to Set
-    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuestion<St> {}
-    impl<St: State> State for SetQuestion<St> {
-        type Question = Set<members::question>;
-        type Certainty = St::Certainty;
-        type Timestamp = St::Timestamp;
-        type Text = St::Text;
-    }
-    ///State transition - sets the `certainty` field to Set
-    pub struct SetCertainty<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCertainty<St> {}
-    impl<St: State> State for SetCertainty<St> {
-        type Question = St::Question;
-        type Certainty = Set<members::certainty>;
-        type Timestamp = St::Timestamp;
-        type Text = St::Text;
+        type Certainty = Unset;
     }
     ///State transition - sets the `timestamp` field to Set
     pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTimestamp<St> {}
     impl<St: State> State for SetTimestamp<St> {
+        type Timestamp = Set<members::timestamp>;
         type Question = St::Question;
+        type Text = St::Text;
         type Certainty = St::Certainty;
-        type Timestamp = Set<members::timestamp>;
+    }
+    ///State transition - sets the `question` field to Set
+    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuestion<St> {}
+    impl<St: State> State for SetQuestion<St> {
+        type Timestamp = St::Timestamp;
+        type Question = Set<members::question>;
         type Text = St::Text;
+        type Certainty = St::Certainty;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
+        type Timestamp = St::Timestamp;
         type Question = St::Question;
+        type Text = Set<members::text>;
         type Certainty = St::Certainty;
+    }
+    ///State transition - sets the `certainty` field to Set
+    pub struct SetCertainty<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCertainty<St> {}
+    impl<St: State> State for SetCertainty<St> {
         type Timestamp = St::Timestamp;
-        type Text = Set<members::text>;
+        type Question = St::Question;
+        type Text = St::Text;
+        type Certainty = Set<members::certainty>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `question` field
-        pub struct question(());
-        ///Marker type for the `certainty` field
-        pub struct certainty(());
         ///Marker type for the `timestamp` field
         pub struct timestamp(());
+        ///Marker type for the `question` field
+        pub struct question(());
         ///Marker type for the `text` field
         pub struct text(());
+        ///Marker type for the `certainty` field
+        pub struct certainty(());
     }
 }
 
@@ -403,10 +403,10 @@ where
 impl<S: BosStr, St> AnswerBuilder<S, St>
 where
     St: answer_state::State,
-    St::Question: answer_state::IsSet,
-    St::Certainty: answer_state::IsSet,
     St::Timestamp: answer_state::IsSet,
+    St::Question: answer_state::IsSet,
     St::Text: answer_state::IsSet,
+    St::Certainty: answer_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Answer<S> {
diff --git a/crates/jacquard-api/src/pub_quizzy/league.rs b/crates/jacquard-api/src/pub_quizzy/league.rs
index 7983eaea..257175c6 100644
--- a/crates/jacquard-api/src/pub_quizzy/league.rs
+++ b/crates/jacquard-api/src/pub_quizzy/league.rs
@@ -174,51 +174,51 @@ pub mod league_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Teams;
         type Name;
         type QuizMasters;
+        type Teams;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Teams = Unset;
         type Name = Unset;
         type QuizMasters = Unset;
-    }
-    ///State transition - sets the `teams` field to Set
-    pub struct SetTeams<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTeams<St> {}
-    impl<St: State> State for SetTeams<St> {
-        type Teams = Set<members::teams>;
-        type Name = St::Name;
-        type QuizMasters = St::QuizMasters;
+        type Teams = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Teams = St::Teams;
         type Name = Set<members::name>;
         type QuizMasters = St::QuizMasters;
+        type Teams = St::Teams;
     }
     ///State transition - sets the `quiz_masters` field to Set
     pub struct SetQuizMasters<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetQuizMasters<St> {}
     impl<St: State> State for SetQuizMasters<St> {
-        type Teams = St::Teams;
         type Name = St::Name;
         type QuizMasters = Set<members::quiz_masters>;
+        type Teams = St::Teams;
+    }
+    ///State transition - sets the `teams` field to Set
+    pub struct SetTeams<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTeams<St> {}
+    impl<St: State> State for SetTeams<St> {
+        type Name = St::Name;
+        type QuizMasters = St::QuizMasters;
+        type Teams = Set<members::teams>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `teams` field
-        pub struct teams(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `quiz_masters` field
         pub struct quiz_masters(());
+        ///Marker type for the `teams` field
+        pub struct teams(());
     }
 }
 
@@ -307,9 +307,9 @@ where
 impl<S: BosStr, St> LeagueBuilder<S, St>
 where
     St: league_state::State,
-    St::Teams: league_state::IsSet,
     St::Name: league_state::IsSet,
     St::QuizMasters: league_state::IsSet,
+    St::Teams: league_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> League<S> {
diff --git a/crates/jacquard-api/src/pub_quizzy/quiz.rs b/crates/jacquard-api/src/pub_quizzy/quiz.rs
index 8721cca6..217fd619 100644
--- a/crates/jacquard-api/src/pub_quizzy/quiz.rs
+++ b/crates/jacquard-api/src/pub_quizzy/quiz.rs
@@ -344,67 +344,67 @@ pub mod quiz_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
-        type Rounds;
         type Locales;
         type Timestamp;
+        type Title;
+        type Rounds;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
-        type Rounds = Unset;
         type Locales = Unset;
         type Timestamp = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Rounds = St::Rounds;
-        type Locales = St::Locales;
-        type Timestamp = St::Timestamp;
-    }
-    ///State transition - sets the `rounds` field to Set
-    pub struct SetRounds<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRounds<St> {}
-    impl<St: State> State for SetRounds<St> {
-        type Title = St::Title;
-        type Rounds = Set<members::rounds>;
-        type Locales = St::Locales;
-        type Timestamp = St::Timestamp;
+        type Title = Unset;
+        type Rounds = Unset;
     }
     ///State transition - sets the `locales` field to Set
     pub struct SetLocales<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLocales<St> {}
     impl<St: State> State for SetLocales<St> {
-        type Title = St::Title;
-        type Rounds = St::Rounds;
         type Locales = Set<members::locales>;
         type Timestamp = St::Timestamp;
+        type Title = St::Title;
+        type Rounds = St::Rounds;
     }
     ///State transition - sets the `timestamp` field to Set
     pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTimestamp<St> {}
     impl<St: State> State for SetTimestamp<St> {
+        type Locales = St::Locales;
+        type Timestamp = Set<members::timestamp>;
         type Title = St::Title;
         type Rounds = St::Rounds;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
         type Locales = St::Locales;
-        type Timestamp = Set<members::timestamp>;
+        type Timestamp = St::Timestamp;
+        type Title = Set<members::title>;
+        type Rounds = St::Rounds;
+    }
+    ///State transition - sets the `rounds` field to Set
+    pub struct SetRounds<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRounds<St> {}
+    impl<St: State> State for SetRounds<St> {
+        type Locales = St::Locales;
+        type Timestamp = St::Timestamp;
+        type Title = St::Title;
+        type Rounds = Set<members::rounds>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `rounds` field
-        pub struct rounds(());
         ///Marker type for the `locales` field
         pub struct locales(());
         ///Marker type for the `timestamp` field
         pub struct timestamp(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `rounds` field
+        pub struct rounds(());
     }
 }
 
@@ -573,10 +573,10 @@ where
 impl<S: BosStr, St> QuizBuilder<S, St>
 where
     St: quiz_state::State,
-    St::Title: quiz_state::IsSet,
-    St::Rounds: quiz_state::IsSet,
     St::Locales: quiz_state::IsSet,
     St::Timestamp: quiz_state::IsSet,
+    St::Title: quiz_state::IsSet,
+    St::Rounds: quiz_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Quiz<S> {
diff --git a/crates/jacquard-api/src/pub_quizzy/quiz_begin.rs b/crates/jacquard-api/src/pub_quizzy/quiz_begin.rs
index 8da9fdec..fac29e0c 100644
--- a/crates/jacquard-api/src/pub_quizzy/quiz_begin.rs
+++ b/crates/jacquard-api/src/pub_quizzy/quiz_begin.rs
@@ -119,67 +119,67 @@ pub mod quiz_begin_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type EndsAt;
         type League;
-        type Quiz;
         type StartedAt;
-        type EndsAt;
+        type Quiz;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type EndsAt = Unset;
         type League = Unset;
-        type Quiz = Unset;
         type StartedAt = Unset;
-        type EndsAt = Unset;
+        type Quiz = Unset;
+    }
+    ///State transition - sets the `ends_at` field to Set
+    pub struct SetEndsAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEndsAt<St> {}
+    impl<St: State> State for SetEndsAt<St> {
+        type EndsAt = Set<members::ends_at>;
+        type League = St::League;
+        type StartedAt = St::StartedAt;
+        type Quiz = St::Quiz;
     }
     ///State transition - sets the `league` field to Set
     pub struct SetLeague<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLeague<St> {}
     impl<St: State> State for SetLeague<St> {
-        type League = Set<members::league>;
-        type Quiz = St::Quiz;
-        type StartedAt = St::StartedAt;
         type EndsAt = St::EndsAt;
-    }
-    ///State transition - sets the `quiz` field to Set
-    pub struct SetQuiz<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuiz<St> {}
-    impl<St: State> State for SetQuiz<St> {
-        type League = St::League;
-        type Quiz = Set<members::quiz>;
+        type League = Set<members::league>;
         type StartedAt = St::StartedAt;
-        type EndsAt = St::EndsAt;
+        type Quiz = St::Quiz;
     }
     ///State transition - sets the `started_at` field to Set
     pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStartedAt<St> {}
     impl<St: State> State for SetStartedAt<St> {
+        type EndsAt = St::EndsAt;
         type League = St::League;
-        type Quiz = St::Quiz;
         type StartedAt = Set<members::started_at>;
-        type EndsAt = St::EndsAt;
+        type Quiz = St::Quiz;
     }
-    ///State transition - sets the `ends_at` field to Set
-    pub struct SetEndsAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEndsAt<St> {}
-    impl<St: State> State for SetEndsAt<St> {
+    ///State transition - sets the `quiz` field to Set
+    pub struct SetQuiz<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuiz<St> {}
+    impl<St: State> State for SetQuiz<St> {
+        type EndsAt = St::EndsAt;
         type League = St::League;
-        type Quiz = St::Quiz;
         type StartedAt = St::StartedAt;
-        type EndsAt = Set<members::ends_at>;
+        type Quiz = Set<members::quiz>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `ends_at` field
+        pub struct ends_at(());
         ///Marker type for the `league` field
         pub struct league(());
-        ///Marker type for the `quiz` field
-        pub struct quiz(());
         ///Marker type for the `started_at` field
         pub struct started_at(());
-        ///Marker type for the `ends_at` field
-        pub struct ends_at(());
+        ///Marker type for the `quiz` field
+        pub struct quiz(());
     }
 }
 
@@ -292,10 +292,10 @@ where
 impl<S: BosStr, St> QuizBeginBuilder<S, St>
 where
     St: quiz_begin_state::State,
+    St::EndsAt: quiz_begin_state::IsSet,
     St::League: quiz_begin_state::IsSet,
-    St::Quiz: quiz_begin_state::IsSet,
     St::StartedAt: quiz_begin_state::IsSet,
-    St::EndsAt: quiz_begin_state::IsSet,
+    St::Quiz: quiz_begin_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> QuizBegin<S> {
diff --git a/crates/jacquard-api/src/pub_quizzy/quiz_done.rs b/crates/jacquard-api/src/pub_quizzy/quiz_done.rs
index db246421..cd59f601 100644
--- a/crates/jacquard-api/src/pub_quizzy/quiz_done.rs
+++ b/crates/jacquard-api/src/pub_quizzy/quiz_done.rs
@@ -115,37 +115,37 @@ pub mod quiz_done_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Timestamp;
         type QuizBegin;
+        type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Timestamp = Unset;
         type QuizBegin = Unset;
-    }
-    ///State transition - sets the `timestamp` field to Set
-    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
-    impl<St: State> State for SetTimestamp<St> {
-        type Timestamp = Set<members::timestamp>;
-        type QuizBegin = St::QuizBegin;
+        type Timestamp = Unset;
     }
     ///State transition - sets the `quiz_begin` field to Set
     pub struct SetQuizBegin<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetQuizBegin<St> {}
     impl<St: State> State for SetQuizBegin<St> {
-        type Timestamp = St::Timestamp;
         type QuizBegin = Set<members::quiz_begin>;
+        type Timestamp = St::Timestamp;
+    }
+    ///State transition - sets the `timestamp` field to Set
+    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
+    impl<St: State> State for SetTimestamp<St> {
+        type QuizBegin = St::QuizBegin;
+        type Timestamp = Set<members::timestamp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `timestamp` field
-        pub struct timestamp(());
         ///Marker type for the `quiz_begin` field
         pub struct quiz_begin(());
+        ///Marker type for the `timestamp` field
+        pub struct timestamp(());
     }
 }
 
@@ -215,8 +215,8 @@ where
 impl<S: BosStr, St> QuizDoneBuilder<S, St>
 where
     St: quiz_done_state::State,
-    St::Timestamp: quiz_done_state::IsSet,
     St::QuizBegin: quiz_done_state::IsSet,
+    St::Timestamp: quiz_done_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> QuizDone<S> {
diff --git a/crates/jacquard-api/src/science_alt/dataset/entry.rs b/crates/jacquard-api/src/science_alt/dataset/entry.rs
index 301fc25b..0e7dabc3 100644
--- a/crates/jacquard-api/src/science_alt/dataset/entry.rs
+++ b/crates/jacquard-api/src/science_alt/dataset/entry.rs
@@ -578,66 +578,66 @@ pub mod entry_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Storage;
-        type Name;
         type SchemaRef;
+        type Name;
+        type Storage;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Storage = Unset;
-        type Name = Unset;
         type SchemaRef = Unset;
+        type Name = Unset;
+        type Storage = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Storage = St::Storage;
-        type Name = St::Name;
         type SchemaRef = St::SchemaRef;
+        type Name = St::Name;
+        type Storage = St::Storage;
     }
-    ///State transition - sets the `storage` field to Set
-    pub struct SetStorage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStorage<St> {}
-    impl<St: State> State for SetStorage<St> {
+    ///State transition - sets the `schema_ref` field to Set
+    pub struct SetSchemaRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSchemaRef<St> {}
+    impl<St: State> State for SetSchemaRef<St> {
         type CreatedAt = St::CreatedAt;
-        type Storage = Set<members::storage>;
+        type SchemaRef = Set<members::schema_ref>;
         type Name = St::Name;
-        type SchemaRef = St::SchemaRef;
+        type Storage = St::Storage;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type CreatedAt = St::CreatedAt;
-        type Storage = St::Storage;
-        type Name = Set<members::name>;
         type SchemaRef = St::SchemaRef;
+        type Name = Set<members::name>;
+        type Storage = St::Storage;
     }
-    ///State transition - sets the `schema_ref` field to Set
-    pub struct SetSchemaRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSchemaRef<St> {}
-    impl<St: State> State for SetSchemaRef<St> {
+    ///State transition - sets the `storage` field to Set
+    pub struct SetStorage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStorage<St> {}
+    impl<St: State> State for SetStorage<St> {
         type CreatedAt = St::CreatedAt;
-        type Storage = St::Storage;
+        type SchemaRef = St::SchemaRef;
         type Name = St::Name;
-        type SchemaRef = Set<members::schema_ref>;
+        type Storage = Set<members::storage>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `storage` field
-        pub struct storage(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `schema_ref` field
         pub struct schema_ref(());
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `storage` field
+        pub struct storage(());
     }
 }
 
@@ -849,9 +849,9 @@ impl<S: BosStr, St> EntryBuilder<S, St>
 where
     St: entry_state::State,
     St::CreatedAt: entry_state::IsSet,
-    St::Storage: entry_state::IsSet,
-    St::Name: entry_state::IsSet,
     St::SchemaRef: entry_state::IsSet,
+    St::Name: entry_state::IsSet,
+    St::Storage: entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Entry<S> {
diff --git a/crates/jacquard-api/src/science_alt/dataset/lens.rs b/crates/jacquard-api/src/science_alt/dataset/lens.rs
index 4fde3912..e0dc1e87 100644
--- a/crates/jacquard-api/src/science_alt/dataset/lens.rs
+++ b/crates/jacquard-api/src/science_alt/dataset/lens.rs
@@ -565,10 +565,10 @@ pub mod lens_state {
     pub trait State: sealed::Sealed {
         type SourceSchema;
         type GetterCode;
-        type PutterCode;
         type CreatedAt;
-        type TargetSchema;
+        type PutterCode;
         type Name;
+        type TargetSchema;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -576,10 +576,10 @@ pub mod lens_state {
     impl State for Empty {
         type SourceSchema = Unset;
         type GetterCode = Unset;
-        type PutterCode = Unset;
         type CreatedAt = Unset;
-        type TargetSchema = Unset;
+        type PutterCode = Unset;
         type Name = Unset;
+        type TargetSchema = Unset;
     }
     ///State transition - sets the `source_schema` field to Set
     pub struct SetSourceSchema<St: State = Empty>(PhantomData<fn() -> St>);
@@ -587,10 +587,10 @@ pub mod lens_state {
     impl<St: State> State for SetSourceSchema<St> {
         type SourceSchema = Set<members::source_schema>;
         type GetterCode = St::GetterCode;
-        type PutterCode = St::PutterCode;
         type CreatedAt = St::CreatedAt;
-        type TargetSchema = St::TargetSchema;
+        type PutterCode = St::PutterCode;
         type Name = St::Name;
+        type TargetSchema = St::TargetSchema;
     }
     ///State transition - sets the `getter_code` field to Set
     pub struct SetGetterCode<St: State = Empty>(PhantomData<fn() -> St>);
@@ -598,21 +598,10 @@ pub mod lens_state {
     impl<St: State> State for SetGetterCode<St> {
         type SourceSchema = St::SourceSchema;
         type GetterCode = Set<members::getter_code>;
-        type PutterCode = St::PutterCode;
         type CreatedAt = St::CreatedAt;
-        type TargetSchema = St::TargetSchema;
+        type PutterCode = St::PutterCode;
         type Name = St::Name;
-    }
-    ///State transition - sets the `putter_code` field to Set
-    pub struct SetPutterCode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPutterCode<St> {}
-    impl<St: State> State for SetPutterCode<St> {
-        type SourceSchema = St::SourceSchema;
-        type GetterCode = St::GetterCode;
-        type PutterCode = Set<members::putter_code>;
-        type CreatedAt = St::CreatedAt;
         type TargetSchema = St::TargetSchema;
-        type Name = St::Name;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -620,21 +609,21 @@ pub mod lens_state {
     impl<St: State> State for SetCreatedAt<St> {
         type SourceSchema = St::SourceSchema;
         type GetterCode = St::GetterCode;
-        type PutterCode = St::PutterCode;
         type CreatedAt = Set<members::created_at>;
-        type TargetSchema = St::TargetSchema;
+        type PutterCode = St::PutterCode;
         type Name = St::Name;
+        type TargetSchema = St::TargetSchema;
     }
-    ///State transition - sets the `target_schema` field to Set
-    pub struct SetTargetSchema<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTargetSchema<St> {}
-    impl<St: State> State for SetTargetSchema<St> {
+    ///State transition - sets the `putter_code` field to Set
+    pub struct SetPutterCode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPutterCode<St> {}
+    impl<St: State> State for SetPutterCode<St> {
         type SourceSchema = St::SourceSchema;
         type GetterCode = St::GetterCode;
-        type PutterCode = St::PutterCode;
         type CreatedAt = St::CreatedAt;
-        type TargetSchema = Set<members::target_schema>;
+        type PutterCode = Set<members::putter_code>;
         type Name = St::Name;
+        type TargetSchema = St::TargetSchema;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
@@ -642,10 +631,21 @@ pub mod lens_state {
     impl<St: State> State for SetName<St> {
         type SourceSchema = St::SourceSchema;
         type GetterCode = St::GetterCode;
-        type PutterCode = St::PutterCode;
         type CreatedAt = St::CreatedAt;
-        type TargetSchema = St::TargetSchema;
+        type PutterCode = St::PutterCode;
         type Name = Set<members::name>;
+        type TargetSchema = St::TargetSchema;
+    }
+    ///State transition - sets the `target_schema` field to Set
+    pub struct SetTargetSchema<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTargetSchema<St> {}
+    impl<St: State> State for SetTargetSchema<St> {
+        type SourceSchema = St::SourceSchema;
+        type GetterCode = St::GetterCode;
+        type CreatedAt = St::CreatedAt;
+        type PutterCode = St::PutterCode;
+        type Name = St::Name;
+        type TargetSchema = Set<members::target_schema>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -654,14 +654,14 @@ pub mod lens_state {
         pub struct source_schema(());
         ///Marker type for the `getter_code` field
         pub struct getter_code(());
-        ///Marker type for the `putter_code` field
-        pub struct putter_code(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `target_schema` field
-        pub struct target_schema(());
+        ///Marker type for the `putter_code` field
+        pub struct putter_code(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `target_schema` field
+        pub struct target_schema(());
     }
 }
 
@@ -886,10 +886,10 @@ where
     St: lens_state::State,
     St::SourceSchema: lens_state::IsSet,
     St::GetterCode: lens_state::IsSet,
-    St::PutterCode: lens_state::IsSet,
     St::CreatedAt: lens_state::IsSet,
-    St::TargetSchema: lens_state::IsSet,
+    St::PutterCode: lens_state::IsSet,
     St::Name: lens_state::IsSet,
+    St::TargetSchema: lens_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Lens<S> {
diff --git a/crates/jacquard-api/src/science_alt/dataset/lens_verification.rs b/crates/jacquard-api/src/science_alt/dataset/lens_verification.rs
index 97a41bf4..42a86836 100644
--- a/crates/jacquard-api/src/science_alt/dataset/lens_verification.rs
+++ b/crates/jacquard-api/src/science_alt/dataset/lens_verification.rs
@@ -374,67 +374,67 @@ pub mod lens_verification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
+        type Lens;
         type LensCommit;
         type VerificationMethod;
-        type Lens;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
+        type Lens = Unset;
         type LensCommit = Unset;
         type VerificationMethod = Unset;
-        type Lens = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Lens = St::Lens;
+        type LensCommit = St::LensCommit;
+        type VerificationMethod = St::VerificationMethod;
+    }
+    ///State transition - sets the `lens` field to Set
+    pub struct SetLens<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLens<St> {}
+    impl<St: State> State for SetLens<St> {
+        type CreatedAt = St::CreatedAt;
+        type Lens = Set<members::lens>;
+        type LensCommit = St::LensCommit;
+        type VerificationMethod = St::VerificationMethod;
     }
     ///State transition - sets the `lens_commit` field to Set
     pub struct SetLensCommit<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLensCommit<St> {}
     impl<St: State> State for SetLensCommit<St> {
+        type CreatedAt = St::CreatedAt;
+        type Lens = St::Lens;
         type LensCommit = Set<members::lens_commit>;
         type VerificationMethod = St::VerificationMethod;
-        type Lens = St::Lens;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `verification_method` field to Set
     pub struct SetVerificationMethod<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVerificationMethod<St> {}
     impl<St: State> State for SetVerificationMethod<St> {
-        type LensCommit = St::LensCommit;
-        type VerificationMethod = Set<members::verification_method>;
-        type Lens = St::Lens;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `lens` field to Set
-    pub struct SetLens<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLens<St> {}
-    impl<St: State> State for SetLens<St> {
-        type LensCommit = St::LensCommit;
-        type VerificationMethod = St::VerificationMethod;
-        type Lens = Set<members::lens>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type LensCommit = St::LensCommit;
-        type VerificationMethod = St::VerificationMethod;
         type Lens = St::Lens;
-        type CreatedAt = Set<members::created_at>;
+        type LensCommit = St::LensCommit;
+        type VerificationMethod = Set<members::verification_method>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `lens` field
+        pub struct lens(());
         ///Marker type for the `lens_commit` field
         pub struct lens_commit(());
         ///Marker type for the `verification_method` field
         pub struct verification_method(());
-        ///Marker type for the `lens` field
-        pub struct lens(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -595,10 +595,10 @@ where
 impl<S: BosStr, St> LensVerificationBuilder<S, St>
 where
     St: lens_verification_state::State,
+    St::CreatedAt: lens_verification_state::IsSet,
+    St::Lens: lens_verification_state::IsSet,
     St::LensCommit: lens_verification_state::IsSet,
     St::VerificationMethod: lens_verification_state::IsSet,
-    St::Lens: lens_verification_state::IsSet,
-    St::CreatedAt: lens_verification_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LensVerification<S> {
diff --git a/crates/jacquard-api/src/science_alt/dataset/resolve_label.rs b/crates/jacquard-api/src/science_alt/dataset/resolve_label.rs
index 812a6430..70f54692 100644
--- a/crates/jacquard-api/src/science_alt/dataset/resolve_label.rs
+++ b/crates/jacquard-api/src/science_alt/dataset/resolve_label.rs
@@ -119,37 +119,37 @@ pub mod resolve_label_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Name;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Name = St::Name;
+        type Handle = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Handle = St::Handle;
         type Name = Set<members::name>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Name = St::Name;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -232,8 +232,8 @@ impl<S: BosStr, St: resolve_label_state::State> ResolveLabelBuilder<S, St> {
 impl<S: BosStr, St> ResolveLabelBuilder<S, St>
 where
     St: resolve_label_state::State,
-    St::Handle: resolve_label_state::IsSet,
     St::Name: resolve_label_state::IsSet,
+    St::Handle: resolve_label_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ResolveLabel<S> {
diff --git a/crates/jacquard-api/src/science_alt/dataset/storage_s3.rs b/crates/jacquard-api/src/science_alt/dataset/storage_s3.rs
index da0e3f1e..df13d109 100644
--- a/crates/jacquard-api/src/science_alt/dataset/storage_s3.rs
+++ b/crates/jacquard-api/src/science_alt/dataset/storage_s3.rs
@@ -151,37 +151,37 @@ pub mod storage_s3_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Bucket;
         type Shards;
+        type Bucket;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Bucket = Unset;
         type Shards = Unset;
-    }
-    ///State transition - sets the `bucket` field to Set
-    pub struct SetBucket<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBucket<St> {}
-    impl<St: State> State for SetBucket<St> {
-        type Bucket = Set<members::bucket>;
-        type Shards = St::Shards;
+        type Bucket = Unset;
     }
     ///State transition - sets the `shards` field to Set
     pub struct SetShards<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetShards<St> {}
     impl<St: State> State for SetShards<St> {
-        type Bucket = St::Bucket;
         type Shards = Set<members::shards>;
+        type Bucket = St::Bucket;
+    }
+    ///State transition - sets the `bucket` field to Set
+    pub struct SetBucket<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBucket<St> {}
+    impl<St: State> State for SetBucket<St> {
+        type Shards = St::Shards;
+        type Bucket = Set<members::bucket>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `bucket` field
-        pub struct bucket(());
         ///Marker type for the `shards` field
         pub struct shards(());
+        ///Marker type for the `bucket` field
+        pub struct bucket(());
     }
 }
 
@@ -282,8 +282,8 @@ where
 impl<S: BosStr, St> StorageS3Builder<S, St>
 where
     St: storage_s3_state::State,
-    St::Bucket: storage_s3_state::IsSet,
     St::Shards: storage_s3_state::IsSet,
+    St::Bucket: storage_s3_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> StorageS3<S> {
@@ -446,37 +446,37 @@ pub mod shard_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Checksum;
         type Key;
+        type Checksum;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Checksum = Unset;
         type Key = Unset;
-    }
-    ///State transition - sets the `checksum` field to Set
-    pub struct SetChecksum<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChecksum<St> {}
-    impl<St: State> State for SetChecksum<St> {
-        type Checksum = Set<members::checksum>;
-        type Key = St::Key;
+        type Checksum = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Checksum = St::Checksum;
         type Key = Set<members::key>;
+        type Checksum = St::Checksum;
+    }
+    ///State transition - sets the `checksum` field to Set
+    pub struct SetChecksum<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChecksum<St> {}
+    impl<St: State> State for SetChecksum<St> {
+        type Key = St::Key;
+        type Checksum = Set<members::checksum>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `checksum` field
-        pub struct checksum(());
         ///Marker type for the `key` field
         pub struct key(());
+        ///Marker type for the `checksum` field
+        pub struct checksum(());
     }
 }
 
@@ -546,8 +546,8 @@ where
 impl<S: BosStr, St> ShardEntryBuilder<S, St>
 where
     St: shard_entry_state::State,
-    St::Checksum: shard_entry_state::IsSet,
     St::Key: shard_entry_state::IsSet,
+    St::Checksum: shard_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ShardEntry<S> {
diff --git a/crates/jacquard-api/src/scot_comhairle/testing_polis_statement_v1.rs b/crates/jacquard-api/src/scot_comhairle/testing_polis_statement_v1.rs
index c1f95c4d..61a30170 100644
--- a/crates/jacquard-api/src/scot_comhairle/testing_polis_statement_v1.rs
+++ b/crates/jacquard-api/src/scot_comhairle/testing_polis_statement_v1.rs
@@ -157,51 +157,51 @@ pub mod testing_polis_statement_v1_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Poll;
         type Text;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Poll = Unset;
         type Text = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Poll = St::Poll;
+        type Text = St::Text;
     }
     ///State transition - sets the `poll` field to Set
     pub struct SetPoll<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPoll<St> {}
     impl<St: State> State for SetPoll<St> {
+        type CreatedAt = St::CreatedAt;
         type Poll = Set<members::poll>;
         type Text = St::Text;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
-        type Poll = St::Poll;
-        type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Poll = St::Poll;
-        type Text = St::Text;
-        type CreatedAt = Set<members::created_at>;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `poll` field
         pub struct poll(());
         ///Marker type for the `text` field
         pub struct text(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -311,9 +311,9 @@ where
 impl<S: BosStr, St> TestingPolisStatementV1Builder<S, St>
 where
     St: testing_polis_statement_v1_state::State,
+    St::CreatedAt: testing_polis_statement_v1_state::IsSet,
     St::Poll: testing_polis_statement_v1_state::IsSet,
     St::Text: testing_polis_statement_v1_state::IsSet,
-    St::CreatedAt: testing_polis_statement_v1_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TestingPolisStatementV1<S> {
@@ -454,37 +454,37 @@ pub mod poll_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Cid;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
+        type Uri = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
         type Cid = Set<members::cid>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -554,8 +554,8 @@ where
 impl<S: BosStr, St> PollRefBuilder<S, St>
 where
     St: poll_ref_state::State,
-    St::Uri: poll_ref_state::IsSet,
     St::Cid: poll_ref_state::IsSet,
+    St::Uri: poll_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PollRef<S> {
diff --git a/crates/jacquard-api/src/scot_comhairle/testing_polis_vote_v1.rs b/crates/jacquard-api/src/scot_comhairle/testing_polis_vote_v1.rs
index e35db1a8..93cdce72 100644
--- a/crates/jacquard-api/src/scot_comhairle/testing_polis_vote_v1.rs
+++ b/crates/jacquard-api/src/scot_comhairle/testing_polis_vote_v1.rs
@@ -175,67 +175,67 @@ pub mod testing_polis_vote_v1_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Poll;
+        type Value;
         type CreatedAt;
         type Subject;
-        type Value;
+        type Poll;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Poll = Unset;
+        type Value = Unset;
         type CreatedAt = Unset;
         type Subject = Unset;
-        type Value = Unset;
+        type Poll = Unset;
     }
-    ///State transition - sets the `poll` field to Set
-    pub struct SetPoll<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPoll<St> {}
-    impl<St: State> State for SetPoll<St> {
-        type Poll = Set<members::poll>;
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Value = Set<members::value>;
         type CreatedAt = St::CreatedAt;
         type Subject = St::Subject;
-        type Value = St::Value;
+        type Poll = St::Poll;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Poll = St::Poll;
+        type Value = St::Value;
         type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-        type Value = St::Value;
+        type Poll = St::Poll;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Poll = St::Poll;
+        type Value = St::Value;
         type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
-        type Value = St::Value;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
         type Poll = St::Poll;
+    }
+    ///State transition - sets the `poll` field to Set
+    pub struct SetPoll<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPoll<St> {}
+    impl<St: State> State for SetPoll<St> {
+        type Value = St::Value;
         type CreatedAt = St::CreatedAt;
         type Subject = St::Subject;
-        type Value = Set<members::value>;
+        type Poll = Set<members::poll>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `poll` field
-        pub struct poll(());
+        ///Marker type for the `value` field
+        pub struct value(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `value` field
-        pub struct value(());
+        ///Marker type for the `poll` field
+        pub struct poll(());
     }
 }
 
@@ -348,10 +348,10 @@ where
 impl<S: BosStr, St> TestingPolisVoteV1Builder<S, St>
 where
     St: testing_polis_vote_v1_state::State,
-    St::Poll: testing_polis_vote_v1_state::IsSet,
+    St::Value: testing_polis_vote_v1_state::IsSet,
     St::CreatedAt: testing_polis_vote_v1_state::IsSet,
     St::Subject: testing_polis_vote_v1_state::IsSet,
-    St::Value: testing_polis_vote_v1_state::IsSet,
+    St::Poll: testing_polis_vote_v1_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TestingPolisVoteV1<S> {
@@ -667,37 +667,37 @@ pub mod statement_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
+        type Cid = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -767,8 +767,8 @@ where
 impl<S: BosStr, St> StatementRefBuilder<S, St>
 where
     St: statement_ref_state::State,
-    St::Cid: statement_ref_state::IsSet,
     St::Uri: statement_ref_state::IsSet,
+    St::Cid: statement_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> StatementRef<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/feed/reaction.rs b/crates/jacquard-api/src/sh_tangled/feed/reaction.rs
index 0753afdf..d473b1ac 100644
--- a/crates/jacquard-api/src/sh_tangled/feed/reaction.rs
+++ b/crates/jacquard-api/src/sh_tangled/feed/reaction.rs
@@ -112,51 +112,51 @@ pub mod reaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Reaction;
         type Subject;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Reaction = Unset;
         type Subject = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Reaction = St::Reaction;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `reaction` field to Set
     pub struct SetReaction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReaction<St> {}
     impl<St: State> State for SetReaction<St> {
+        type CreatedAt = St::CreatedAt;
         type Reaction = Set<members::reaction>;
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Reaction = St::Reaction;
-        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Reaction = St::Reaction;
-        type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `reaction` field
         pub struct reaction(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -245,9 +245,9 @@ where
 impl<S: BosStr, St> ReactionBuilder<S, St>
 where
     St: reaction_state::State,
+    St::CreatedAt: reaction_state::IsSet,
     St::Reaction: reaction_state::IsSet,
     St::Subject: reaction_state::IsSet,
-    St::CreatedAt: reaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reaction<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/ref_update.rs b/crates/jacquard-api/src/sh_tangled/git/ref_update.rs
index 1b0d2fce..43d544d6 100644
--- a/crates/jacquard-api/src/sh_tangled/git/ref_update.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/ref_update.rs
@@ -848,127 +848,127 @@ pub mod ref_update_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Ref;
         type RepoDid;
-        type NewSha;
+        type RepoName;
         type Meta;
+        type Ref;
+        type NewSha;
         type CommitterDid;
         type OldSha;
-        type RepoName;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Ref = Unset;
         type RepoDid = Unset;
-        type NewSha = Unset;
+        type RepoName = Unset;
         type Meta = Unset;
+        type Ref = Unset;
+        type NewSha = Unset;
         type CommitterDid = Unset;
         type OldSha = Unset;
-        type RepoName = Unset;
-    }
-    ///State transition - sets the `ref` field to Set
-    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRef<St> {}
-    impl<St: State> State for SetRef<St> {
-        type Ref = Set<members::r#ref>;
-        type RepoDid = St::RepoDid;
-        type NewSha = St::NewSha;
-        type Meta = St::Meta;
-        type CommitterDid = St::CommitterDid;
-        type OldSha = St::OldSha;
-        type RepoName = St::RepoName;
     }
     ///State transition - sets the `repo_did` field to Set
     pub struct SetRepoDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepoDid<St> {}
     impl<St: State> State for SetRepoDid<St> {
-        type Ref = St::Ref;
         type RepoDid = Set<members::repo_did>;
-        type NewSha = St::NewSha;
+        type RepoName = St::RepoName;
         type Meta = St::Meta;
+        type Ref = St::Ref;
+        type NewSha = St::NewSha;
         type CommitterDid = St::CommitterDid;
         type OldSha = St::OldSha;
-        type RepoName = St::RepoName;
     }
-    ///State transition - sets the `new_sha` field to Set
-    pub struct SetNewSha<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNewSha<St> {}
-    impl<St: State> State for SetNewSha<St> {
-        type Ref = St::Ref;
+    ///State transition - sets the `repo_name` field to Set
+    pub struct SetRepoName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepoName<St> {}
+    impl<St: State> State for SetRepoName<St> {
         type RepoDid = St::RepoDid;
-        type NewSha = Set<members::new_sha>;
+        type RepoName = Set<members::repo_name>;
         type Meta = St::Meta;
+        type Ref = St::Ref;
+        type NewSha = St::NewSha;
         type CommitterDid = St::CommitterDid;
         type OldSha = St::OldSha;
-        type RepoName = St::RepoName;
     }
     ///State transition - sets the `meta` field to Set
     pub struct SetMeta<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMeta<St> {}
     impl<St: State> State for SetMeta<St> {
+        type RepoDid = St::RepoDid;
+        type RepoName = St::RepoName;
+        type Meta = Set<members::meta>;
         type Ref = St::Ref;
+        type NewSha = St::NewSha;
+        type CommitterDid = St::CommitterDid;
+        type OldSha = St::OldSha;
+    }
+    ///State transition - sets the `ref` field to Set
+    pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRef<St> {}
+    impl<St: State> State for SetRef<St> {
         type RepoDid = St::RepoDid;
+        type RepoName = St::RepoName;
+        type Meta = St::Meta;
+        type Ref = Set<members::r#ref>;
         type NewSha = St::NewSha;
-        type Meta = Set<members::meta>;
         type CommitterDid = St::CommitterDid;
         type OldSha = St::OldSha;
+    }
+    ///State transition - sets the `new_sha` field to Set
+    pub struct SetNewSha<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNewSha<St> {}
+    impl<St: State> State for SetNewSha<St> {
+        type RepoDid = St::RepoDid;
         type RepoName = St::RepoName;
+        type Meta = St::Meta;
+        type Ref = St::Ref;
+        type NewSha = Set<members::new_sha>;
+        type CommitterDid = St::CommitterDid;
+        type OldSha = St::OldSha;
     }
     ///State transition - sets the `committer_did` field to Set
     pub struct SetCommitterDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCommitterDid<St> {}
     impl<St: State> State for SetCommitterDid<St> {
-        type Ref = St::Ref;
         type RepoDid = St::RepoDid;
-        type NewSha = St::NewSha;
+        type RepoName = St::RepoName;
         type Meta = St::Meta;
+        type Ref = St::Ref;
+        type NewSha = St::NewSha;
         type CommitterDid = Set<members::committer_did>;
         type OldSha = St::OldSha;
-        type RepoName = St::RepoName;
     }
     ///State transition - sets the `old_sha` field to Set
     pub struct SetOldSha<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOldSha<St> {}
     impl<St: State> State for SetOldSha<St> {
-        type Ref = St::Ref;
         type RepoDid = St::RepoDid;
-        type NewSha = St::NewSha;
-        type Meta = St::Meta;
-        type CommitterDid = St::CommitterDid;
-        type OldSha = Set<members::old_sha>;
         type RepoName = St::RepoName;
-    }
-    ///State transition - sets the `repo_name` field to Set
-    pub struct SetRepoName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepoName<St> {}
-    impl<St: State> State for SetRepoName<St> {
+        type Meta = St::Meta;
         type Ref = St::Ref;
-        type RepoDid = St::RepoDid;
         type NewSha = St::NewSha;
-        type Meta = St::Meta;
         type CommitterDid = St::CommitterDid;
-        type OldSha = St::OldSha;
-        type RepoName = Set<members::repo_name>;
+        type OldSha = Set<members::old_sha>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `ref` field
-        pub struct r#ref(());
         ///Marker type for the `repo_did` field
         pub struct repo_did(());
-        ///Marker type for the `new_sha` field
-        pub struct new_sha(());
+        ///Marker type for the `repo_name` field
+        pub struct repo_name(());
         ///Marker type for the `meta` field
         pub struct meta(());
+        ///Marker type for the `ref` field
+        pub struct r#ref(());
+        ///Marker type for the `new_sha` field
+        pub struct new_sha(());
         ///Marker type for the `committer_did` field
         pub struct committer_did(());
         ///Marker type for the `old_sha` field
         pub struct old_sha(());
-        ///Marker type for the `repo_name` field
-        pub struct repo_name(());
     }
 }
 
@@ -1141,13 +1141,13 @@ where
 impl<S: BosStr, St> RefUpdateBuilder<S, St>
 where
     St: ref_update_state::State,
-    St::Ref: ref_update_state::IsSet,
     St::RepoDid: ref_update_state::IsSet,
-    St::NewSha: ref_update_state::IsSet,
+    St::RepoName: ref_update_state::IsSet,
     St::Meta: ref_update_state::IsSet,
+    St::Ref: ref_update_state::IsSet,
+    St::NewSha: ref_update_state::IsSet,
     St::CommitterDid: ref_update_state::IsSet,
     St::OldSha: ref_update_state::IsSet,
-    St::RepoName: ref_update_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RefUpdate<S> {
@@ -1194,37 +1194,37 @@ pub mod meta_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IsDefaultRef;
         type CommitCount;
+        type IsDefaultRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IsDefaultRef = Unset;
         type CommitCount = Unset;
-    }
-    ///State transition - sets the `is_default_ref` field to Set
-    pub struct SetIsDefaultRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIsDefaultRef<St> {}
-    impl<St: State> State for SetIsDefaultRef<St> {
-        type IsDefaultRef = Set<members::is_default_ref>;
-        type CommitCount = St::CommitCount;
+        type IsDefaultRef = Unset;
     }
     ///State transition - sets the `commit_count` field to Set
     pub struct SetCommitCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCommitCount<St> {}
     impl<St: State> State for SetCommitCount<St> {
-        type IsDefaultRef = St::IsDefaultRef;
         type CommitCount = Set<members::commit_count>;
+        type IsDefaultRef = St::IsDefaultRef;
+    }
+    ///State transition - sets the `is_default_ref` field to Set
+    pub struct SetIsDefaultRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIsDefaultRef<St> {}
+    impl<St: State> State for SetIsDefaultRef<St> {
+        type CommitCount = St::CommitCount;
+        type IsDefaultRef = Set<members::is_default_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `is_default_ref` field
-        pub struct is_default_ref(());
         ///Marker type for the `commit_count` field
         pub struct commit_count(());
+        ///Marker type for the `is_default_ref` field
+        pub struct is_default_ref(());
     }
 }
 
@@ -1317,8 +1317,8 @@ impl<S: BosStr, St: meta_state::State> MetaBuilder<S, St> {
 impl<S: BosStr, St> MetaBuilder<S, St>
 where
     St: meta_state::State,
-    St::IsDefaultRef: meta_state::IsSet,
     St::CommitCount: meta_state::IsSet,
+    St::IsDefaultRef: meta_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Meta<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp.rs b/crates/jacquard-api/src/sh_tangled/git/temp.rs
index bbbebc97..f7455217 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp.rs
@@ -228,67 +228,67 @@ pub mod blob_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type LastCommit;
         type Mode;
         type Size;
         type Name;
-        type LastCommit;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type LastCommit = Unset;
         type Mode = Unset;
         type Size = Unset;
         type Name = Unset;
-        type LastCommit = Unset;
+    }
+    ///State transition - sets the `last_commit` field to Set
+    pub struct SetLastCommit<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLastCommit<St> {}
+    impl<St: State> State for SetLastCommit<St> {
+        type LastCommit = Set<members::last_commit>;
+        type Mode = St::Mode;
+        type Size = St::Size;
+        type Name = St::Name;
     }
     ///State transition - sets the `mode` field to Set
     pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMode<St> {}
     impl<St: State> State for SetMode<St> {
+        type LastCommit = St::LastCommit;
         type Mode = Set<members::mode>;
         type Size = St::Size;
         type Name = St::Name;
-        type LastCommit = St::LastCommit;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
+        type LastCommit = St::LastCommit;
         type Mode = St::Mode;
         type Size = Set<members::size>;
         type Name = St::Name;
-        type LastCommit = St::LastCommit;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Mode = St::Mode;
-        type Size = St::Size;
-        type Name = Set<members::name>;
         type LastCommit = St::LastCommit;
-    }
-    ///State transition - sets the `last_commit` field to Set
-    pub struct SetLastCommit<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLastCommit<St> {}
-    impl<St: State> State for SetLastCommit<St> {
         type Mode = St::Mode;
         type Size = St::Size;
-        type Name = St::Name;
-        type LastCommit = Set<members::last_commit>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `last_commit` field
+        pub struct last_commit(());
         ///Marker type for the `mode` field
         pub struct mode(());
         ///Marker type for the `size` field
         pub struct size(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `last_commit` field
-        pub struct last_commit(());
     }
 }
 
@@ -415,10 +415,10 @@ impl<S: BosStr, St: blob_state::State> BlobBuilder<S, St> {
 impl<S: BosStr, St> BlobBuilder<S, St>
 where
     St: blob_state::State,
+    St::LastCommit: blob_state::IsSet,
     St::Mode: blob_state::IsSet,
     St::Size: blob_state::IsSet,
     St::Name: blob_state::IsSet,
-    St::LastCommit: blob_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Blob<S> {
@@ -858,85 +858,85 @@ pub mod commit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Message;
         type Committer;
         type Author;
-        type Tree;
-        type Message;
         type Hash;
+        type Tree;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Message = Unset;
         type Committer = Unset;
         type Author = Unset;
-        type Tree = Unset;
-        type Message = Unset;
         type Hash = Unset;
+        type Tree = Unset;
+    }
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type Message = Set<members::message>;
+        type Committer = St::Committer;
+        type Author = St::Author;
+        type Hash = St::Hash;
+        type Tree = St::Tree;
     }
     ///State transition - sets the `committer` field to Set
     pub struct SetCommitter<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCommitter<St> {}
     impl<St: State> State for SetCommitter<St> {
+        type Message = St::Message;
         type Committer = Set<members::committer>;
         type Author = St::Author;
-        type Tree = St::Tree;
-        type Message = St::Message;
         type Hash = St::Hash;
+        type Tree = St::Tree;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Committer = St::Committer;
-        type Author = Set<members::author>;
-        type Tree = St::Tree;
         type Message = St::Message;
-        type Hash = St::Hash;
-    }
-    ///State transition - sets the `tree` field to Set
-    pub struct SetTree<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTree<St> {}
-    impl<St: State> State for SetTree<St> {
         type Committer = St::Committer;
-        type Author = St::Author;
-        type Tree = Set<members::tree>;
-        type Message = St::Message;
+        type Author = Set<members::author>;
         type Hash = St::Hash;
-    }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
-        type Committer = St::Committer;
-        type Author = St::Author;
         type Tree = St::Tree;
-        type Message = Set<members::message>;
-        type Hash = St::Hash;
     }
     ///State transition - sets the `hash` field to Set
     pub struct SetHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHash<St> {}
     impl<St: State> State for SetHash<St> {
+        type Message = St::Message;
         type Committer = St::Committer;
         type Author = St::Author;
+        type Hash = Set<members::hash>;
         type Tree = St::Tree;
+    }
+    ///State transition - sets the `tree` field to Set
+    pub struct SetTree<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTree<St> {}
+    impl<St: State> State for SetTree<St> {
         type Message = St::Message;
-        type Hash = Set<members::hash>;
+        type Committer = St::Committer;
+        type Author = St::Author;
+        type Hash = St::Hash;
+        type Tree = Set<members::tree>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `message` field
+        pub struct message(());
         ///Marker type for the `committer` field
         pub struct committer(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `tree` field
-        pub struct tree(());
-        ///Marker type for the `message` field
-        pub struct message(());
         ///Marker type for the `hash` field
         pub struct hash(());
+        ///Marker type for the `tree` field
+        pub struct tree(());
     }
 }
 
@@ -1069,11 +1069,11 @@ where
 impl<S: BosStr, St> CommitBuilder<S, St>
 where
     St: commit_state::State,
+    St::Message: commit_state::IsSet,
     St::Committer: commit_state::IsSet,
     St::Author: commit_state::IsSet,
-    St::Tree: commit_state::IsSet,
-    St::Message: commit_state::IsSet,
     St::Hash: commit_state::IsSet,
+    St::Tree: commit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Commit<S> {
@@ -1110,50 +1110,50 @@ pub mod signature_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type When;
-        type Name;
         type Email;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type When = Unset;
-        type Name = Unset;
         type Email = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
         type When = Set<members::when>;
-        type Name = St::Name;
-        type Email = St::Email;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type When = St::When;
-        type Name = Set<members::name>;
         type Email = St::Email;
+        type Name = St::Name;
     }
     ///State transition - sets the `email` field to Set
     pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEmail<St> {}
     impl<St: State> State for SetEmail<St> {
         type When = St::When;
-        type Name = St::Name;
         type Email = Set<members::email>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type When = St::When;
+        type Email = St::Email;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `when` field
         pub struct when(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `email` field
         pub struct email(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -1243,8 +1243,8 @@ impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
     St::When: signature_state::IsSet,
-    St::Name: signature_state::IsSet,
     St::Email: signature_state::IsSet,
+    St::Name: signature_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Signature<S> {
@@ -1280,50 +1280,50 @@ pub mod tag_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Name;
-        type Tagger;
         type Target;
+        type Tagger;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Name = Unset;
-        type Tagger = Unset;
         type Target = Unset;
+        type Tagger = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type Name = Set<members::name>;
-        type Tagger = St::Tagger;
-        type Target = St::Target;
-    }
-    ///State transition - sets the `tagger` field to Set
-    pub struct SetTagger<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTagger<St> {}
-    impl<St: State> State for SetTagger<St> {
-        type Name = St::Name;
-        type Tagger = Set<members::tagger>;
         type Target = St::Target;
+        type Tagger = St::Tagger;
     }
     ///State transition - sets the `target` field to Set
     pub struct SetTarget<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTarget<St> {}
     impl<St: State> State for SetTarget<St> {
         type Name = St::Name;
-        type Tagger = St::Tagger;
         type Target = Set<members::target>;
+        type Tagger = St::Tagger;
+    }
+    ///State transition - sets the `tagger` field to Set
+    pub struct SetTagger<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTagger<St> {}
+    impl<St: State> State for SetTagger<St> {
+        type Name = St::Name;
+        type Target = St::Target;
+        type Tagger = Set<members::tagger>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `tagger` field
-        pub struct tagger(());
         ///Marker type for the `target` field
         pub struct target(());
+        ///Marker type for the `tagger` field
+        pub struct tagger(());
     }
 }
 
@@ -1423,8 +1423,8 @@ impl<S: BosStr, St> TagBuilder<S, St>
 where
     St: tag_state::State,
     St::Name: tag_state::IsSet,
-    St::Tagger: tag_state::IsSet,
     St::Target: tag_state::IsSet,
+    St::Tagger: tag_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Tag<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/analyze_merge.rs b/crates/jacquard-api/src/sh_tangled/git/temp/analyze_merge.rs
index 2c4651a5..3ac438c1 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/analyze_merge.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/analyze_merge.rs
@@ -211,51 +211,51 @@ pub mod analyze_merge_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Branch;
-        type Repo;
         type Patch;
+        type Repo;
+        type Branch;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Branch = Unset;
-        type Repo = Unset;
         type Patch = Unset;
+        type Repo = Unset;
+        type Branch = Unset;
     }
-    ///State transition - sets the `branch` field to Set
-    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBranch<St> {}
-    impl<St: State> State for SetBranch<St> {
-        type Branch = Set<members::branch>;
+    ///State transition - sets the `patch` field to Set
+    pub struct SetPatch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPatch<St> {}
+    impl<St: State> State for SetPatch<St> {
+        type Patch = Set<members::patch>;
         type Repo = St::Repo;
-        type Patch = St::Patch;
+        type Branch = St::Branch;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Branch = St::Branch;
-        type Repo = Set<members::repo>;
         type Patch = St::Patch;
-    }
-    ///State transition - sets the `patch` field to Set
-    pub struct SetPatch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPatch<St> {}
-    impl<St: State> State for SetPatch<St> {
+        type Repo = Set<members::repo>;
         type Branch = St::Branch;
+    }
+    ///State transition - sets the `branch` field to Set
+    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBranch<St> {}
+    impl<St: State> State for SetBranch<St> {
+        type Patch = St::Patch;
         type Repo = St::Repo;
-        type Patch = Set<members::patch>;
+        type Branch = Set<members::branch>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `branch` field
-        pub struct branch(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `patch` field
         pub struct patch(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
+        ///Marker type for the `branch` field
+        pub struct branch(());
     }
 }
 
@@ -344,9 +344,9 @@ where
 impl<S: BosStr, St> AnalyzeMergeBuilder<S, St>
 where
     St: analyze_merge_state::State,
-    St::Branch: analyze_merge_state::IsSet,
-    St::Repo: analyze_merge_state::IsSet,
     St::Patch: analyze_merge_state::IsSet,
+    St::Repo: analyze_merge_state::IsSet,
+    St::Branch: analyze_merge_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AnalyzeMerge<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/get_branch.rs b/crates/jacquard-api/src/sh_tangled/git/temp/get_branch.rs
index e6c7088a..7810221a 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/get_branch.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/get_branch.rs
@@ -141,37 +141,37 @@ pub mod get_branch_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Repo;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Repo = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Repo = St::Repo;
+        type Name = Unset;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Name = St::Name;
         type Repo = Set<members::repo>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Repo = St::Repo;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -241,8 +241,8 @@ where
 impl<S: BosStr, St> GetBranchBuilder<S, St>
 where
     St: get_branch_state::State,
-    St::Name: get_branch_state::IsSet,
     St::Repo: get_branch_state::IsSet,
+    St::Name: get_branch_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetBranch<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/get_commit.rs b/crates/jacquard-api/src/sh_tangled/git/temp/get_commit.rs
index 9c55fb29..f2d5b66a 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/get_commit.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/get_commit.rs
@@ -132,37 +132,37 @@ pub mod get_commit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Ref;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Ref = St::Ref;
+        type Repo = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type Repo = St::Repo;
         type Ref = Set<members::r#ref>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Ref = St::Ref;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -232,8 +232,8 @@ where
 impl<S: BosStr, St> GetCommitBuilder<S, St>
 where
     St: get_commit_state::State,
-    St::Repo: get_commit_state::IsSet,
     St::Ref: get_commit_state::IsSet,
+    St::Repo: get_commit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetCommit<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/get_diff.rs b/crates/jacquard-api/src/sh_tangled/git/temp/get_diff.rs
index 6a1fe772..26c3ec6d 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/get_diff.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/get_diff.rs
@@ -160,51 +160,51 @@ pub mod get_diff_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Rev2;
-        type Rev1;
         type Repo;
+        type Rev1;
+        type Rev2;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Rev2 = Unset;
-        type Rev1 = Unset;
         type Repo = Unset;
+        type Rev1 = Unset;
+        type Rev2 = Unset;
     }
-    ///State transition - sets the `rev2` field to Set
-    pub struct SetRev2<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRev2<St> {}
-    impl<St: State> State for SetRev2<St> {
-        type Rev2 = Set<members::rev2>;
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Repo = Set<members::repo>;
         type Rev1 = St::Rev1;
-        type Repo = St::Repo;
+        type Rev2 = St::Rev2;
     }
     ///State transition - sets the `rev1` field to Set
     pub struct SetRev1<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRev1<St> {}
     impl<St: State> State for SetRev1<St> {
-        type Rev2 = St::Rev2;
-        type Rev1 = Set<members::rev1>;
         type Repo = St::Repo;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
+        type Rev1 = Set<members::rev1>;
         type Rev2 = St::Rev2;
+    }
+    ///State transition - sets the `rev2` field to Set
+    pub struct SetRev2<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRev2<St> {}
+    impl<St: State> State for SetRev2<St> {
+        type Repo = St::Repo;
         type Rev1 = St::Rev1;
-        type Repo = Set<members::repo>;
+        type Rev2 = Set<members::rev2>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `rev2` field
-        pub struct rev2(());
-        ///Marker type for the `rev1` field
-        pub struct rev1(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `rev1` field
+        pub struct rev1(());
+        ///Marker type for the `rev2` field
+        pub struct rev2(());
     }
 }
 
@@ -293,9 +293,9 @@ where
 impl<S: BosStr, St> GetDiffBuilder<S, St>
 where
     St: get_diff_state::State,
-    St::Rev2: get_diff_state::IsSet,
-    St::Rev1: get_diff_state::IsSet,
     St::Repo: get_diff_state::IsSet,
+    St::Rev1: get_diff_state::IsSet,
+    St::Rev2: get_diff_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetDiff<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/get_entity.rs b/crates/jacquard-api/src/sh_tangled/git/temp/get_entity.rs
index 82a50721..61898903 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/get_entity.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/get_entity.rs
@@ -140,37 +140,37 @@ pub mod get_entity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Path;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Path = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Path = St::Path;
+        type Repo = Unset;
     }
     ///State transition - sets the `path` field to Set
     pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPath<St> {}
     impl<St: State> State for SetPath<St> {
-        type Repo = St::Repo;
         type Path = Set<members::path>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Path = St::Path;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `path` field
         pub struct path(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -253,8 +253,8 @@ where
 impl<S: BosStr, St> GetEntityBuilder<S, St>
 where
     St: get_entity_state::State,
-    St::Repo: get_entity_state::IsSet,
     St::Path: get_entity_state::IsSet,
+    St::Repo: get_entity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetEntity<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/get_tree.rs b/crates/jacquard-api/src/sh_tangled/git/temp/get_tree.rs
index e13e45c3..bb40eee6 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/get_tree.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/get_tree.rs
@@ -284,49 +284,49 @@ pub mod last_commit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Message;
         type Hash;
+        type Message;
         type When;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Message = Unset;
         type Hash = Unset;
+        type Message = Unset;
         type When = Unset;
     }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
-        type Message = Set<members::message>;
-        type Hash = St::Hash;
-        type When = St::When;
-    }
     ///State transition - sets the `hash` field to Set
     pub struct SetHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHash<St> {}
     impl<St: State> State for SetHash<St> {
-        type Message = St::Message;
         type Hash = Set<members::hash>;
+        type Message = St::Message;
+        type When = St::When;
+    }
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type Hash = St::Hash;
+        type Message = Set<members::message>;
         type When = St::When;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Message = St::Message;
         type Hash = St::Hash;
+        type Message = St::Message;
         type When = Set<members::when>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `message` field
-        pub struct message(());
         ///Marker type for the `hash` field
         pub struct hash(());
+        ///Marker type for the `message` field
+        pub struct message(());
         ///Marker type for the `when` field
         pub struct when(());
     }
@@ -430,8 +430,8 @@ where
 impl<S: BosStr, St> LastCommitBuilder<S, St>
 where
     St: last_commit_state::State,
-    St::Message: last_commit_state::IsSet,
     St::Hash: last_commit_state::IsSet,
+    St::Message: last_commit_state::IsSet,
     St::When: last_commit_state::IsSet,
 {
     /// Build the final struct.
@@ -842,49 +842,49 @@ pub mod signature_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Email;
         type Name;
+        type Email;
         type When;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Email = Unset;
         type Name = Unset;
+        type Email = Unset;
         type When = Unset;
     }
-    ///State transition - sets the `email` field to Set
-    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEmail<St> {}
-    impl<St: State> State for SetEmail<St> {
-        type Email = Set<members::email>;
-        type Name = St::Name;
-        type When = St::When;
-    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Email = St::Email;
         type Name = Set<members::name>;
+        type Email = St::Email;
+        type When = St::When;
+    }
+    ///State transition - sets the `email` field to Set
+    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEmail<St> {}
+    impl<St: State> State for SetEmail<St> {
+        type Name = St::Name;
+        type Email = Set<members::email>;
         type When = St::When;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Email = St::Email;
         type Name = St::Name;
+        type Email = St::Email;
         type When = Set<members::when>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `email` field
-        pub struct email(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `email` field
+        pub struct email(());
         ///Marker type for the `when` field
         pub struct when(());
     }
@@ -975,8 +975,8 @@ where
 impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
-    St::Email: signature_state::IsSet,
     St::Name: signature_state::IsSet,
+    St::Email: signature_state::IsSet,
     St::When: signature_state::IsSet,
 {
     /// Build the final struct.
@@ -1012,51 +1012,51 @@ pub mod tree_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Name;
         type Mode;
         type Size;
-        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Name = Unset;
         type Mode = Unset;
         type Size = Unset;
-        type Name = Unset;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
+        type Mode = St::Mode;
+        type Size = St::Size;
     }
     ///State transition - sets the `mode` field to Set
     pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMode<St> {}
     impl<St: State> State for SetMode<St> {
+        type Name = St::Name;
         type Mode = Set<members::mode>;
         type Size = St::Size;
-        type Name = St::Name;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type Mode = St::Mode;
-        type Size = Set<members::size>;
         type Name = St::Name;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type Mode = St::Mode;
-        type Size = St::Size;
-        type Name = Set<members::name>;
+        type Size = Set<members::size>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `mode` field
         pub struct mode(());
         ///Marker type for the `size` field
         pub struct size(());
-        ///Marker type for the `name` field
-        pub struct name(());
     }
 }
 
@@ -1161,9 +1161,9 @@ where
 impl<S: BosStr, St> TreeEntryBuilder<S, St>
 where
     St: tree_entry_state::State,
+    St::Name: tree_entry_state::IsSet,
     St::Mode: tree_entry_state::IsSet,
     St::Size: tree_entry_state::IsSet,
-    St::Name: tree_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TreeEntry<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/git/temp/list_languages.rs b/crates/jacquard-api/src/sh_tangled/git/temp/list_languages.rs
index c509aa69..28736051 100644
--- a/crates/jacquard-api/src/sh_tangled/git/temp/list_languages.rs
+++ b/crates/jacquard-api/src/sh_tangled/git/temp/list_languages.rs
@@ -188,51 +188,51 @@ pub mod language_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Percentage;
         type Size;
         type Name;
+        type Percentage;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Percentage = Unset;
         type Size = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `percentage` field to Set
-    pub struct SetPercentage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPercentage<St> {}
-    impl<St: State> State for SetPercentage<St> {
-        type Percentage = Set<members::percentage>;
-        type Size = St::Size;
-        type Name = St::Name;
+        type Percentage = Unset;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type Percentage = St::Percentage;
         type Size = Set<members::size>;
         type Name = St::Name;
+        type Percentage = St::Percentage;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Percentage = St::Percentage;
         type Size = St::Size;
         type Name = Set<members::name>;
+        type Percentage = St::Percentage;
+    }
+    ///State transition - sets the `percentage` field to Set
+    pub struct SetPercentage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPercentage<St> {}
+    impl<St: State> State for SetPercentage<St> {
+        type Size = St::Size;
+        type Name = St::Name;
+        type Percentage = Set<members::percentage>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `percentage` field
-        pub struct percentage(());
         ///Marker type for the `size` field
         pub struct size(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `percentage` field
+        pub struct percentage(());
     }
 }
 
@@ -367,9 +367,9 @@ where
 impl<S: BosStr, St> LanguageBuilder<S, St>
 where
     St: language_state::State,
-    St::Percentage: language_state::IsSet,
     St::Size: language_state::IsSet,
     St::Name: language_state::IsSet,
+    St::Percentage: language_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Language<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/graph/follow.rs b/crates/jacquard-api/src/sh_tangled/graph/follow.rs
index 2c3e6153..de8d02a5 100644
--- a/crates/jacquard-api/src/sh_tangled/graph/follow.rs
+++ b/crates/jacquard-api/src/sh_tangled/graph/follow.rs
@@ -111,37 +111,37 @@ pub mod follow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -211,8 +211,8 @@ where
 impl<S: BosStr, St> FollowBuilder<S, St>
 where
     St: follow_state::State,
-    St::CreatedAt: follow_state::IsSet,
     St::Subject: follow_state::IsSet,
+    St::CreatedAt: follow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Follow<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs b/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs
index e23c90c1..118c5181 100644
--- a/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs
+++ b/crates/jacquard-api/src/sh_tangled/knot/list_keys.rs
@@ -253,51 +253,51 @@ pub mod public_key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Key;
         type Did;
         type CreatedAt;
+        type Key;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Key = Unset;
         type Did = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `key` field to Set
-    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKey<St> {}
-    impl<St: State> State for SetKey<St> {
-        type Key = Set<members::key>;
-        type Did = St::Did;
-        type CreatedAt = St::CreatedAt;
+        type Key = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Key = St::Key;
         type Did = Set<members::did>;
         type CreatedAt = St::CreatedAt;
+        type Key = St::Key;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Key = St::Key;
         type Did = St::Did;
         type CreatedAt = Set<members::created_at>;
+        type Key = St::Key;
+    }
+    ///State transition - sets the `key` field to Set
+    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKey<St> {}
+    impl<St: State> State for SetKey<St> {
+        type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
+        type Key = Set<members::key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `key` field
-        pub struct key(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `key` field
+        pub struct key(());
     }
 }
 
@@ -386,9 +386,9 @@ where
 impl<S: BosStr, St> PublicKeyBuilder<S, St>
 where
     St: public_key_state::State,
-    St::Key: public_key_state::IsSet,
     St::Did: public_key_state::IsSet,
     St::CreatedAt: public_key_state::IsSet,
+    St::Key: public_key_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PublicKey<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/knot/member.rs b/crates/jacquard-api/src/sh_tangled/knot/member.rs
index 52eb3361..37fecb91 100644
--- a/crates/jacquard-api/src/sh_tangled/knot/member.rs
+++ b/crates/jacquard-api/src/sh_tangled/knot/member.rs
@@ -114,50 +114,50 @@ pub mod member_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Domain;
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Domain = Unset;
-        type Subject = Unset;
         type CreatedAt = Unset;
+        type Subject = Unset;
     }
     ///State transition - sets the `domain` field to Set
     pub struct SetDomain<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDomain<St> {}
     impl<St: State> State for SetDomain<St> {
         type Domain = Set<members::domain>;
-        type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Domain = St::Domain;
-        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Domain = St::Domain;
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Domain = St::Domain;
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `domain` field
         pub struct domain(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -247,8 +247,8 @@ impl<S: BosStr, St> MemberBuilder<S, St>
 where
     St: member_state::State,
     St::Domain: member_state::IsSet,
-    St::Subject: member_state::IsSet,
     St::CreatedAt: member_state::IsSet,
+    St::Subject: member_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Member<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/knot/subscribe_repos.rs b/crates/jacquard-api/src/sh_tangled/knot/subscribe_repos.rs
index 4f2154fc..a0f70f7a 100644
--- a/crates/jacquard-api/src/sh_tangled/knot/subscribe_repos.rs
+++ b/crates/jacquard-api/src/sh_tangled/knot/subscribe_repos.rs
@@ -246,37 +246,37 @@ pub mod git_sync1_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Seq;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Seq = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Seq = St::Seq;
+        type Did = Unset;
     }
     ///State transition - sets the `seq` field to Set
     pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeq<St> {}
     impl<St: State> State for SetSeq<St> {
-        type Did = St::Did;
         type Seq = Set<members::seq>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Seq = St::Seq;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `seq` field
         pub struct seq(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -346,8 +346,8 @@ where
 impl<S: BosStr, St> GitSync1Builder<S, St>
 where
     St: git_sync1_state::State,
-    St::Did: git_sync1_state::IsSet,
     St::Seq: git_sync1_state::IsSet,
+    St::Did: git_sync1_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GitSync1<S> {
@@ -640,51 +640,51 @@ pub mod identity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
-        type Seq;
         type Time;
+        type Seq;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
-        type Seq = Unset;
         type Time = Unset;
+        type Seq = Unset;
+        type Did = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
+        type Time = Set<members::time>;
         type Seq = St::Seq;
-        type Time = St::Time;
+        type Did = St::Did;
     }
     ///State transition - sets the `seq` field to Set
     pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeq<St> {}
     impl<St: State> State for SetSeq<St> {
-        type Did = St::Did;
-        type Seq = Set<members::seq>;
         type Time = St::Time;
-    }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
+        type Seq = Set<members::seq>;
         type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Time = St::Time;
         type Seq = St::Seq;
-        type Time = Set<members::time>;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
-        ///Marker type for the `seq` field
-        pub struct seq(());
         ///Marker type for the `time` field
         pub struct time(());
+        ///Marker type for the `seq` field
+        pub struct seq(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -773,9 +773,9 @@ where
 impl<S: BosStr, St> IdentityBuilder<S, St>
 where
     St: identity_state::State,
-    St::Did: identity_state::IsSet,
-    St::Seq: identity_state::IsSet,
     St::Time: identity_state::IsSet,
+    St::Seq: identity_state::IsSet,
+    St::Did: identity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Identity<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/label/definition.rs b/crates/jacquard-api/src/sh_tangled/label/definition.rs
index 2cf819aa..0339e4d8 100644
--- a/crates/jacquard-api/src/sh_tangled/label/definition.rs
+++ b/crates/jacquard-api/src/sh_tangled/label/definition.rs
@@ -179,67 +179,67 @@ pub mod definition_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ValueType;
         type Name;
-        type CreatedAt;
         type Scope;
+        type CreatedAt;
+        type ValueType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ValueType = Unset;
         type Name = Unset;
-        type CreatedAt = Unset;
         type Scope = Unset;
-    }
-    ///State transition - sets the `value_type` field to Set
-    pub struct SetValueType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValueType<St> {}
-    impl<St: State> State for SetValueType<St> {
-        type ValueType = Set<members::value_type>;
-        type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
-        type Scope = St::Scope;
+        type CreatedAt = Unset;
+        type ValueType = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type ValueType = St::ValueType;
         type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
         type Scope = St::Scope;
+        type CreatedAt = St::CreatedAt;
+        type ValueType = St::ValueType;
+    }
+    ///State transition - sets the `scope` field to Set
+    pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScope<St> {}
+    impl<St: State> State for SetScope<St> {
+        type Name = St::Name;
+        type Scope = Set<members::scope>;
+        type CreatedAt = St::CreatedAt;
+        type ValueType = St::ValueType;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type ValueType = St::ValueType;
         type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
         type Scope = St::Scope;
-    }
-    ///State transition - sets the `scope` field to Set
-    pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScope<St> {}
-    impl<St: State> State for SetScope<St> {
+        type CreatedAt = Set<members::created_at>;
         type ValueType = St::ValueType;
+    }
+    ///State transition - sets the `value_type` field to Set
+    pub struct SetValueType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValueType<St> {}
+    impl<St: State> State for SetValueType<St> {
         type Name = St::Name;
+        type Scope = St::Scope;
         type CreatedAt = St::CreatedAt;
-        type Scope = Set<members::scope>;
+        type ValueType = Set<members::value_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `value_type` field
-        pub struct value_type(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `scope` field
         pub struct scope(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `value_type` field
+        pub struct value_type(());
     }
 }
 
@@ -380,10 +380,10 @@ where
 impl<S: BosStr, St> DefinitionBuilder<S, St>
 where
     St: definition_state::State,
-    St::ValueType: definition_state::IsSet,
     St::Name: definition_state::IsSet,
-    St::CreatedAt: definition_state::IsSet,
     St::Scope: definition_state::IsSet,
+    St::CreatedAt: definition_state::IsSet,
+    St::ValueType: definition_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Definition<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/label/op.rs b/crates/jacquard-api/src/sh_tangled/label/op.rs
index d77f5dbf..9fccd0e3 100644
--- a/crates/jacquard-api/src/sh_tangled/label/op.rs
+++ b/crates/jacquard-api/src/sh_tangled/label/op.rs
@@ -142,67 +142,67 @@ pub mod op_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Delete;
         type Subject;
-        type PerformedAt;
         type Add;
+        type PerformedAt;
+        type Delete;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Delete = Unset;
         type Subject = Unset;
-        type PerformedAt = Unset;
         type Add = Unset;
-    }
-    ///State transition - sets the `delete` field to Set
-    pub struct SetDelete<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDelete<St> {}
-    impl<St: State> State for SetDelete<St> {
-        type Delete = Set<members::delete>;
-        type Subject = St::Subject;
-        type PerformedAt = St::PerformedAt;
-        type Add = St::Add;
+        type PerformedAt = Unset;
+        type Delete = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Delete = St::Delete;
         type Subject = Set<members::subject>;
-        type PerformedAt = St::PerformedAt;
         type Add = St::Add;
+        type PerformedAt = St::PerformedAt;
+        type Delete = St::Delete;
+    }
+    ///State transition - sets the `add` field to Set
+    pub struct SetAdd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAdd<St> {}
+    impl<St: State> State for SetAdd<St> {
+        type Subject = St::Subject;
+        type Add = Set<members::add>;
+        type PerformedAt = St::PerformedAt;
+        type Delete = St::Delete;
     }
     ///State transition - sets the `performed_at` field to Set
     pub struct SetPerformedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPerformedAt<St> {}
     impl<St: State> State for SetPerformedAt<St> {
-        type Delete = St::Delete;
         type Subject = St::Subject;
-        type PerformedAt = Set<members::performed_at>;
         type Add = St::Add;
-    }
-    ///State transition - sets the `add` field to Set
-    pub struct SetAdd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAdd<St> {}
-    impl<St: State> State for SetAdd<St> {
+        type PerformedAt = Set<members::performed_at>;
         type Delete = St::Delete;
+    }
+    ///State transition - sets the `delete` field to Set
+    pub struct SetDelete<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDelete<St> {}
+    impl<St: State> State for SetDelete<St> {
         type Subject = St::Subject;
+        type Add = St::Add;
         type PerformedAt = St::PerformedAt;
-        type Add = Set<members::add>;
+        type Delete = Set<members::delete>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `delete` field
-        pub struct delete(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `performed_at` field
-        pub struct performed_at(());
         ///Marker type for the `add` field
         pub struct add(());
+        ///Marker type for the `performed_at` field
+        pub struct performed_at(());
+        ///Marker type for the `delete` field
+        pub struct delete(());
     }
 }
 
@@ -315,10 +315,10 @@ where
 impl<S: BosStr, St> OpBuilder<S, St>
 where
     St: op_state::State,
-    St::Delete: op_state::IsSet,
     St::Subject: op_state::IsSet,
-    St::PerformedAt: op_state::IsSet,
     St::Add: op_state::IsSet,
+    St::PerformedAt: op_state::IsSet,
+    St::Delete: op_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Op<S> {
@@ -464,37 +464,37 @@ pub mod operand_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Value;
         type Key;
+        type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Value = Unset;
         type Key = Unset;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
-        type Value = Set<members::value>;
-        type Key = St::Key;
+        type Value = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Value = St::Value;
         type Key = Set<members::key>;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Key = St::Key;
+        type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `value` field
-        pub struct value(());
         ///Marker type for the `key` field
         pub struct key(());
+        ///Marker type for the `value` field
+        pub struct value(());
     }
 }
 
@@ -564,8 +564,8 @@ where
 impl<S: BosStr, St> OperandBuilder<S, St>
 where
     St: operand_state::State,
-    St::Value: operand_state::IsSet,
     St::Key: operand_state::IsSet,
+    St::Value: operand_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Operand<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/pipeline.rs b/crates/jacquard-api/src/sh_tangled/pipeline.rs
index 23d50d13..a1e84773 100644
--- a/crates/jacquard-api/src/sh_tangled/pipeline.rs
+++ b/crates/jacquard-api/src/sh_tangled/pipeline.rs
@@ -893,37 +893,37 @@ pub mod pipeline_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type TriggerMetadata;
         type Workflows;
+        type TriggerMetadata;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type TriggerMetadata = Unset;
         type Workflows = Unset;
-    }
-    ///State transition - sets the `trigger_metadata` field to Set
-    pub struct SetTriggerMetadata<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTriggerMetadata<St> {}
-    impl<St: State> State for SetTriggerMetadata<St> {
-        type TriggerMetadata = Set<members::trigger_metadata>;
-        type Workflows = St::Workflows;
+        type TriggerMetadata = Unset;
     }
     ///State transition - sets the `workflows` field to Set
     pub struct SetWorkflows<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorkflows<St> {}
     impl<St: State> State for SetWorkflows<St> {
-        type TriggerMetadata = St::TriggerMetadata;
         type Workflows = Set<members::workflows>;
+        type TriggerMetadata = St::TriggerMetadata;
+    }
+    ///State transition - sets the `trigger_metadata` field to Set
+    pub struct SetTriggerMetadata<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTriggerMetadata<St> {}
+    impl<St: State> State for SetTriggerMetadata<St> {
+        type Workflows = St::Workflows;
+        type TriggerMetadata = Set<members::trigger_metadata>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `trigger_metadata` field
-        pub struct trigger_metadata(());
         ///Marker type for the `workflows` field
         pub struct workflows(());
+        ///Marker type for the `trigger_metadata` field
+        pub struct trigger_metadata(());
     }
 }
 
@@ -993,8 +993,8 @@ where
 impl<S: BosStr, St> PipelineBuilder<S, St>
 where
     St: pipeline_state::State,
-    St::TriggerMetadata: pipeline_state::IsSet,
     St::Workflows: pipeline_state::IsSet,
+    St::TriggerMetadata: pipeline_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Pipeline<S> {
@@ -1024,37 +1024,37 @@ pub mod trigger_metadata_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Kind;
         type Repo;
+        type Kind;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Kind = Unset;
         type Repo = Unset;
-    }
-    ///State transition - sets the `kind` field to Set
-    pub struct SetKind<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKind<St> {}
-    impl<St: State> State for SetKind<St> {
-        type Kind = Set<members::kind>;
-        type Repo = St::Repo;
+        type Kind = Unset;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Kind = St::Kind;
         type Repo = Set<members::repo>;
+        type Kind = St::Kind;
+    }
+    ///State transition - sets the `kind` field to Set
+    pub struct SetKind<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKind<St> {}
+    impl<St: State> State for SetKind<St> {
+        type Repo = St::Repo;
+        type Kind = Set<members::kind>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `kind` field
-        pub struct kind(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `kind` field
+        pub struct kind(());
     }
 }
 
@@ -1184,8 +1184,8 @@ where
 impl<S: BosStr, St> TriggerMetadataBuilder<S, St>
 where
     St: trigger_metadata_state::State,
-    St::Kind: trigger_metadata_state::IsSet,
     St::Repo: trigger_metadata_state::IsSet,
+    St::Kind: trigger_metadata_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TriggerMetadata<S> {
@@ -1225,66 +1225,66 @@ pub mod trigger_repo_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Knot;
-        type Repo;
         type Did;
         type DefaultBranch;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Knot = Unset;
-        type Repo = Unset;
         type Did = Unset;
         type DefaultBranch = Unset;
+        type Repo = Unset;
     }
     ///State transition - sets the `knot` field to Set
     pub struct SetKnot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKnot<St> {}
     impl<St: State> State for SetKnot<St> {
         type Knot = Set<members::knot>;
-        type Repo = St::Repo;
-        type Did = St::Did;
-        type DefaultBranch = St::DefaultBranch;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Knot = St::Knot;
-        type Repo = Set<members::repo>;
         type Did = St::Did;
         type DefaultBranch = St::DefaultBranch;
+        type Repo = St::Repo;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
         type Knot = St::Knot;
-        type Repo = St::Repo;
         type Did = Set<members::did>;
         type DefaultBranch = St::DefaultBranch;
+        type Repo = St::Repo;
     }
     ///State transition - sets the `default_branch` field to Set
     pub struct SetDefaultBranch<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDefaultBranch<St> {}
     impl<St: State> State for SetDefaultBranch<St> {
         type Knot = St::Knot;
-        type Repo = St::Repo;
         type Did = St::Did;
         type DefaultBranch = Set<members::default_branch>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Knot = St::Knot;
+        type Did = St::Did;
+        type DefaultBranch = St::DefaultBranch;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `knot` field
         pub struct knot(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `default_branch` field
         pub struct default_branch(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -1393,9 +1393,9 @@ impl<S: BosStr, St> TriggerRepoBuilder<S, St>
 where
     St: trigger_repo_state::State,
     St::Knot: trigger_repo_state::IsSet,
-    St::Repo: trigger_repo_state::IsSet,
     St::Did: trigger_repo_state::IsSet,
     St::DefaultBranch: trigger_repo_state::IsSet,
+    St::Repo: trigger_repo_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TriggerRepo<S> {
@@ -1432,67 +1432,67 @@ pub mod workflow_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Engine;
+        type Raw;
         type Clone;
+        type Engine;
         type Name;
-        type Raw;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Engine = Unset;
+        type Raw = Unset;
         type Clone = Unset;
+        type Engine = Unset;
         type Name = Unset;
-        type Raw = Unset;
     }
-    ///State transition - sets the `engine` field to Set
-    pub struct SetEngine<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEngine<St> {}
-    impl<St: State> State for SetEngine<St> {
-        type Engine = Set<members::engine>;
+    ///State transition - sets the `raw` field to Set
+    pub struct SetRaw<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRaw<St> {}
+    impl<St: State> State for SetRaw<St> {
+        type Raw = Set<members::raw>;
         type Clone = St::Clone;
+        type Engine = St::Engine;
         type Name = St::Name;
-        type Raw = St::Raw;
     }
     ///State transition - sets the `clone` field to Set
     pub struct SetClone<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClone<St> {}
     impl<St: State> State for SetClone<St> {
-        type Engine = St::Engine;
+        type Raw = St::Raw;
         type Clone = Set<members::clone>;
+        type Engine = St::Engine;
         type Name = St::Name;
+    }
+    ///State transition - sets the `engine` field to Set
+    pub struct SetEngine<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEngine<St> {}
+    impl<St: State> State for SetEngine<St> {
         type Raw = St::Raw;
+        type Clone = St::Clone;
+        type Engine = Set<members::engine>;
+        type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Engine = St::Engine;
-        type Clone = St::Clone;
-        type Name = Set<members::name>;
         type Raw = St::Raw;
-    }
-    ///State transition - sets the `raw` field to Set
-    pub struct SetRaw<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRaw<St> {}
-    impl<St: State> State for SetRaw<St> {
-        type Engine = St::Engine;
         type Clone = St::Clone;
-        type Name = St::Name;
-        type Raw = Set<members::raw>;
+        type Engine = St::Engine;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `engine` field
-        pub struct engine(());
+        ///Marker type for the `raw` field
+        pub struct raw(());
         ///Marker type for the `clone` field
         pub struct clone(());
+        ///Marker type for the `engine` field
+        pub struct engine(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `raw` field
-        pub struct raw(());
     }
 }
 
@@ -1600,10 +1600,10 @@ where
 impl<S: BosStr, St> WorkflowBuilder<S, St>
 where
     St: workflow_state::State,
-    St::Engine: workflow_state::IsSet,
+    St::Raw: workflow_state::IsSet,
     St::Clone: workflow_state::IsSet,
+    St::Engine: workflow_state::IsSet,
     St::Name: workflow_state::IsSet,
-    St::Raw: workflow_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Workflow<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/pipeline/cancel_pipeline.rs b/crates/jacquard-api/src/sh_tangled/pipeline/cancel_pipeline.rs
index 3e2f7c10..e4d54ac4 100644
--- a/crates/jacquard-api/src/sh_tangled/pipeline/cancel_pipeline.rs
+++ b/crates/jacquard-api/src/sh_tangled/pipeline/cancel_pipeline.rs
@@ -68,51 +68,51 @@ pub mod cancel_pipeline_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Workflow;
-        type Pipeline;
         type Repo;
+        type Pipeline;
+        type Workflow;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Workflow = Unset;
-        type Pipeline = Unset;
         type Repo = Unset;
+        type Pipeline = Unset;
+        type Workflow = Unset;
     }
-    ///State transition - sets the `workflow` field to Set
-    pub struct SetWorkflow<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWorkflow<St> {}
-    impl<St: State> State for SetWorkflow<St> {
-        type Workflow = Set<members::workflow>;
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Repo = Set<members::repo>;
         type Pipeline = St::Pipeline;
-        type Repo = St::Repo;
+        type Workflow = St::Workflow;
     }
     ///State transition - sets the `pipeline` field to Set
     pub struct SetPipeline<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPipeline<St> {}
     impl<St: State> State for SetPipeline<St> {
-        type Workflow = St::Workflow;
-        type Pipeline = Set<members::pipeline>;
         type Repo = St::Repo;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
+        type Pipeline = Set<members::pipeline>;
         type Workflow = St::Workflow;
+    }
+    ///State transition - sets the `workflow` field to Set
+    pub struct SetWorkflow<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWorkflow<St> {}
+    impl<St: State> State for SetWorkflow<St> {
+        type Repo = St::Repo;
         type Pipeline = St::Pipeline;
-        type Repo = Set<members::repo>;
+        type Workflow = Set<members::workflow>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `workflow` field
-        pub struct workflow(());
-        ///Marker type for the `pipeline` field
-        pub struct pipeline(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `pipeline` field
+        pub struct pipeline(());
+        ///Marker type for the `workflow` field
+        pub struct workflow(());
     }
 }
 
@@ -201,9 +201,9 @@ where
 impl<S: BosStr, St> CancelPipelineBuilder<S, St>
 where
     St: cancel_pipeline_state::State,
-    St::Workflow: cancel_pipeline_state::IsSet,
-    St::Pipeline: cancel_pipeline_state::IsSet,
     St::Repo: cancel_pipeline_state::IsSet,
+    St::Pipeline: cancel_pipeline_state::IsSet,
+    St::Workflow: cancel_pipeline_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CancelPipeline<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/pipeline/status.rs b/crates/jacquard-api/src/sh_tangled/pipeline/status.rs
index 7dead919..9e871a99 100644
--- a/crates/jacquard-api/src/sh_tangled/pipeline/status.rs
+++ b/crates/jacquard-api/src/sh_tangled/pipeline/status.rs
@@ -123,67 +123,67 @@ pub mod status_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Workflow;
         type Status;
-        type CreatedAt;
         type Pipeline;
+        type Workflow;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Workflow = Unset;
         type Status = Unset;
-        type CreatedAt = Unset;
         type Pipeline = Unset;
-    }
-    ///State transition - sets the `workflow` field to Set
-    pub struct SetWorkflow<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWorkflow<St> {}
-    impl<St: State> State for SetWorkflow<St> {
-        type Workflow = Set<members::workflow>;
-        type Status = St::Status;
-        type CreatedAt = St::CreatedAt;
-        type Pipeline = St::Pipeline;
+        type Workflow = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
-        type Workflow = St::Workflow;
         type Status = Set<members::status>;
-        type CreatedAt = St::CreatedAt;
         type Pipeline = St::Pipeline;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Workflow = St::Workflow;
-        type Status = St::Status;
-        type CreatedAt = Set<members::created_at>;
-        type Pipeline = St::Pipeline;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `pipeline` field to Set
     pub struct SetPipeline<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPipeline<St> {}
     impl<St: State> State for SetPipeline<St> {
+        type Status = St::Status;
+        type Pipeline = Set<members::pipeline>;
         type Workflow = St::Workflow;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `workflow` field to Set
+    pub struct SetWorkflow<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWorkflow<St> {}
+    impl<St: State> State for SetWorkflow<St> {
         type Status = St::Status;
+        type Pipeline = St::Pipeline;
+        type Workflow = Set<members::workflow>;
         type CreatedAt = St::CreatedAt;
-        type Pipeline = Set<members::pipeline>;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Status = St::Status;
+        type Pipeline = St::Pipeline;
+        type Workflow = St::Workflow;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `workflow` field
-        pub struct workflow(());
         ///Marker type for the `status` field
         pub struct status(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `pipeline` field
         pub struct pipeline(());
+        ///Marker type for the `workflow` field
+        pub struct workflow(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -324,10 +324,10 @@ where
 impl<S: BosStr, St> StatusBuilder<S, St>
 where
     St: status_state::State,
-    St::Workflow: status_state::IsSet,
     St::Status: status_state::IsSet,
-    St::CreatedAt: status_state::IsSet,
     St::Pipeline: status_state::IsSet,
+    St::Workflow: status_state::IsSet,
+    St::CreatedAt: status_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Status<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/public_key.rs b/crates/jacquard-api/src/sh_tangled/public_key.rs
index 2f09e8f8..c9b387f0 100644
--- a/crates/jacquard-api/src/sh_tangled/public_key.rs
+++ b/crates/jacquard-api/src/sh_tangled/public_key.rs
@@ -126,51 +126,51 @@ pub mod public_key_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Name;
         type Key;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Name = Unset;
         type Key = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+        type Key = St::Key;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type Key = St::Key;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Name = St::Name;
-        type Key = Set<members::key>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Name = St::Name;
-        type Key = St::Key;
-        type CreatedAt = Set<members::created_at>;
+        type Key = Set<members::key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `key` field
         pub struct key(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -259,9 +259,9 @@ where
 impl<S: BosStr, St> PublicKeyBuilder<S, St>
 where
     St: public_key_state::State,
+    St::CreatedAt: public_key_state::IsSet,
     St::Name: public_key_state::IsSet,
     St::Key: public_key_state::IsSet,
-    St::CreatedAt: public_key_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PublicKey<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo.rs b/crates/jacquard-api/src/sh_tangled/repo.rs
index 830e3cbc..dccf6633 100644
--- a/crates/jacquard-api/src/sh_tangled/repo.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo.rs
@@ -195,49 +195,49 @@ pub mod repo_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Knot;
+        type CreatedAt;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Knot = Unset;
+        type CreatedAt = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Knot = St::Knot;
-        type Name = St::Name;
-    }
     ///State transition - sets the `knot` field to Set
     pub struct SetKnot<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKnot<St> {}
     impl<St: State> State for SetKnot<St> {
-        type CreatedAt = St::CreatedAt;
         type Knot = Set<members::knot>;
+        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Knot = St::Knot;
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Knot = St::Knot;
+        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `knot` field
         pub struct knot(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -416,8 +416,8 @@ impl<S: BosStr, St: repo_state::State> RepoBuilder<S, St> {
 impl<S: BosStr, St> RepoBuilder<S, St>
 where
     St: repo_state::State,
-    St::CreatedAt: repo_state::IsSet,
     St::Knot: repo_state::IsSet,
+    St::CreatedAt: repo_state::IsSet,
     St::Name: repo_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/add_secret.rs b/crates/jacquard-api/src/sh_tangled/repo/add_secret.rs
index 0ad08032..9fce4314 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/add_secret.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/add_secret.rs
@@ -65,51 +65,51 @@ pub mod add_secret_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Value;
         type Key;
         type Repo;
-        type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Value = Unset;
         type Key = Unset;
         type Repo = Unset;
-        type Value = Unset;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type Value = Set<members::value>;
+        type Key = St::Key;
+        type Repo = St::Repo;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
+        type Value = St::Value;
         type Key = Set<members::key>;
         type Repo = St::Repo;
-        type Value = St::Value;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type Key = St::Key;
-        type Repo = Set<members::repo>;
         type Value = St::Value;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
         type Key = St::Key;
-        type Repo = St::Repo;
-        type Value = Set<members::value>;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `value` field
+        pub struct value(());
         ///Marker type for the `key` field
         pub struct key(());
         ///Marker type for the `repo` field
         pub struct repo(());
-        ///Marker type for the `value` field
-        pub struct value(());
     }
 }
 
@@ -198,9 +198,9 @@ where
 impl<S: BosStr, St> AddSecretBuilder<S, St>
 where
     St: add_secret_state::State,
+    St::Value: add_secret_state::IsSet,
     St::Key: add_secret_state::IsSet,
     St::Repo: add_secret_state::IsSet,
-    St::Value: add_secret_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AddSecret<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/archive.rs b/crates/jacquard-api/src/sh_tangled/repo/archive.rs
index 9961ee60..012082e2 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/archive.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/archive.rs
@@ -168,37 +168,37 @@ pub mod archive_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Ref;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Ref = St::Ref;
+        type Repo = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type Repo = St::Repo;
         type Ref = Set<members::r#ref>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Ref = St::Ref;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -294,8 +294,8 @@ where
 impl<S: BosStr, St> ArchiveBuilder<S, St>
 where
     St: archive_state::State,
-    St::Repo: archive_state::IsSet,
     St::Ref: archive_state::IsSet,
+    St::Repo: archive_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Archive<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/artifact.rs b/crates/jacquard-api/src/sh_tangled/repo/artifact.rs
index 0b8db64e..16a10a1c 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/artifact.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/artifact.rs
@@ -162,83 +162,83 @@ pub mod artifact_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type Name;
-        type Repo;
         type Tag;
-        type CreatedAt;
+        type Repo;
         type Artifact;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type Name = Unset;
-        type Repo = Unset;
         type Tag = Unset;
-        type CreatedAt = Unset;
+        type Repo = Unset;
         type Artifact = Unset;
     }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+        type Tag = St::Tag;
+        type Repo = St::Repo;
+        type Artifact = St::Artifact;
+    }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Repo = St::Repo;
-        type Tag = St::Tag;
         type CreatedAt = St::CreatedAt;
-        type Artifact = St::Artifact;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Name = St::Name;
-        type Repo = Set<members::repo>;
+        type Name = Set<members::name>;
         type Tag = St::Tag;
-        type CreatedAt = St::CreatedAt;
+        type Repo = St::Repo;
         type Artifact = St::Artifact;
     }
     ///State transition - sets the `tag` field to Set
     pub struct SetTag<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTag<St> {}
     impl<St: State> State for SetTag<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
-        type Repo = St::Repo;
         type Tag = Set<members::tag>;
-        type CreatedAt = St::CreatedAt;
+        type Repo = St::Repo;
         type Artifact = St::Artifact;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
-        type Repo = St::Repo;
         type Tag = St::Tag;
-        type CreatedAt = Set<members::created_at>;
+        type Repo = Set<members::repo>;
         type Artifact = St::Artifact;
     }
     ///State transition - sets the `artifact` field to Set
     pub struct SetArtifact<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetArtifact<St> {}
     impl<St: State> State for SetArtifact<St> {
+        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
-        type Repo = St::Repo;
         type Tag = St::Tag;
-        type CreatedAt = St::CreatedAt;
+        type Repo = St::Repo;
         type Artifact = Set<members::artifact>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `tag` field
         pub struct tag(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
         ///Marker type for the `artifact` field
         pub struct artifact(());
     }
@@ -373,10 +373,10 @@ where
 impl<S: BosStr, St> ArtifactBuilder<S, St>
 where
     St: artifact_state::State,
+    St::CreatedAt: artifact_state::IsSet,
     St::Name: artifact_state::IsSet,
-    St::Repo: artifact_state::IsSet,
     St::Tag: artifact_state::IsSet,
-    St::CreatedAt: artifact_state::IsSet,
+    St::Repo: artifact_state::IsSet,
     St::Artifact: artifact_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/branch.rs b/crates/jacquard-api/src/sh_tangled/repo/branch.rs
index f232c3b1..90221040 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/branch.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/branch.rs
@@ -306,49 +306,49 @@ pub mod signature_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Email;
         type When;
+        type Email;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Email = Unset;
         type When = Unset;
+        type Email = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `email` field to Set
-    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEmail<St> {}
-    impl<St: State> State for SetEmail<St> {
-        type Email = Set<members::email>;
-        type When = St::When;
-        type Name = St::Name;
-    }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Email = St::Email;
         type When = Set<members::when>;
+        type Email = St::Email;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `email` field to Set
+    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEmail<St> {}
+    impl<St: State> State for SetEmail<St> {
+        type When = St::When;
+        type Email = Set<members::email>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Email = St::Email;
         type When = St::When;
+        type Email = St::Email;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `email` field
-        pub struct email(());
         ///Marker type for the `when` field
         pub struct when(());
+        ///Marker type for the `email` field
+        pub struct email(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -439,8 +439,8 @@ where
 impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
-    St::Email: signature_state::IsSet,
     St::When: signature_state::IsSet,
+    St::Email: signature_state::IsSet,
     St::Name: signature_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs b/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs
index 8295883b..86eb828b 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/collaborator.rs
@@ -113,51 +113,51 @@ pub mod collaborator_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
-        type CreatedAt = Unset;
         type Subject = Unset;
+        type CreatedAt = Unset;
+        type Repo = Unset;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
+        type Repo = St::Repo;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Repo = St::Repo;
-        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = Set<members::created_at>;
         type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Subject = St::Subject;
         type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -246,9 +246,9 @@ where
 impl<S: BosStr, St> CollaboratorBuilder<S, St>
 where
     St: collaborator_state::State,
-    St::Repo: collaborator_state::IsSet,
-    St::CreatedAt: collaborator_state::IsSet,
     St::Subject: collaborator_state::IsSet,
+    St::CreatedAt: collaborator_state::IsSet,
+    St::Repo: collaborator_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collaborator<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/diff.rs b/crates/jacquard-api/src/sh_tangled/repo/diff.rs
index c90edf10..6c1a11c9 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/diff.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/diff.rs
@@ -147,37 +147,37 @@ pub mod diff_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Ref;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Ref = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Ref = St::Ref;
+        type Repo = Unset;
     }
     ///State transition - sets the `ref` field to Set
     pub struct SetRef<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRef<St> {}
     impl<St: State> State for SetRef<St> {
-        type Repo = St::Repo;
         type Ref = Set<members::r#ref>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Ref = St::Ref;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `ref` field
         pub struct r#ref(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -247,8 +247,8 @@ where
 impl<S: BosStr, St> DiffBuilder<S, St>
 where
     St: diff_state::State,
-    St::Repo: diff_state::IsSet,
     St::Ref: diff_state::IsSet,
+    St::Repo: diff_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Diff<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/fork_status.rs b/crates/jacquard-api/src/sh_tangled/repo/fork_status.rs
index 72a9fef8..85dbc56a 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/fork_status.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/fork_status.rs
@@ -82,85 +82,85 @@ pub mod fork_status_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type HiddenRef;
         type Did;
         type Branch;
+        type HiddenRef;
         type Source;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type HiddenRef = Unset;
         type Did = Unset;
         type Branch = Unset;
+        type HiddenRef = Unset;
         type Source = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type HiddenRef = St::HiddenRef;
-        type Did = St::Did;
-        type Branch = St::Branch;
-        type Source = St::Source;
-    }
-    ///State transition - sets the `hidden_ref` field to Set
-    pub struct SetHiddenRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHiddenRef<St> {}
-    impl<St: State> State for SetHiddenRef<St> {
-        type Name = St::Name;
-        type HiddenRef = Set<members::hidden_ref>;
-        type Did = St::Did;
-        type Branch = St::Branch;
-        type Source = St::Source;
+        type Name = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Name = St::Name;
-        type HiddenRef = St::HiddenRef;
         type Did = Set<members::did>;
         type Branch = St::Branch;
+        type HiddenRef = St::HiddenRef;
         type Source = St::Source;
+        type Name = St::Name;
     }
     ///State transition - sets the `branch` field to Set
     pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBranch<St> {}
     impl<St: State> State for SetBranch<St> {
-        type Name = St::Name;
-        type HiddenRef = St::HiddenRef;
         type Did = St::Did;
         type Branch = Set<members::branch>;
+        type HiddenRef = St::HiddenRef;
+        type Source = St::Source;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `hidden_ref` field to Set
+    pub struct SetHiddenRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHiddenRef<St> {}
+    impl<St: State> State for SetHiddenRef<St> {
+        type Did = St::Did;
+        type Branch = St::Branch;
+        type HiddenRef = Set<members::hidden_ref>;
         type Source = St::Source;
+        type Name = St::Name;
     }
     ///State transition - sets the `source` field to Set
     pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSource<St> {}
     impl<St: State> State for SetSource<St> {
-        type Name = St::Name;
-        type HiddenRef = St::HiddenRef;
         type Did = St::Did;
         type Branch = St::Branch;
+        type HiddenRef = St::HiddenRef;
         type Source = Set<members::source>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Did = St::Did;
+        type Branch = St::Branch;
+        type HiddenRef = St::HiddenRef;
+        type Source = St::Source;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `hidden_ref` field
-        pub struct hidden_ref(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `branch` field
         pub struct branch(());
+        ///Marker type for the `hidden_ref` field
+        pub struct hidden_ref(());
         ///Marker type for the `source` field
         pub struct source(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -287,11 +287,11 @@ where
 impl<S: BosStr, St> ForkStatusBuilder<S, St>
 where
     St: fork_status_state::State,
-    St::Name: fork_status_state::IsSet,
-    St::HiddenRef: fork_status_state::IsSet,
     St::Did: fork_status_state::IsSet,
     St::Branch: fork_status_state::IsSet,
+    St::HiddenRef: fork_status_state::IsSet,
     St::Source: fork_status_state::IsSet,
+    St::Name: fork_status_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ForkStatus<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/fork_sync.rs b/crates/jacquard-api/src/sh_tangled/repo/fork_sync.rs
index f415c24a..e118a2ef 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/fork_sync.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/fork_sync.rs
@@ -70,65 +70,65 @@ pub mod fork_sync_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Name;
         type Branch;
         type Did;
-        type Name;
         type Source;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Name = Unset;
         type Branch = Unset;
         type Did = Unset;
-        type Name = Unset;
         type Source = Unset;
     }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
+        type Branch = St::Branch;
+        type Did = St::Did;
+        type Source = St::Source;
+    }
     ///State transition - sets the `branch` field to Set
     pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBranch<St> {}
     impl<St: State> State for SetBranch<St> {
+        type Name = St::Name;
         type Branch = Set<members::branch>;
         type Did = St::Did;
-        type Name = St::Name;
         type Source = St::Source;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Branch = St::Branch;
-        type Did = Set<members::did>;
         type Name = St::Name;
-        type Source = St::Source;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type Branch = St::Branch;
-        type Did = St::Did;
-        type Name = Set<members::name>;
+        type Did = Set<members::did>;
         type Source = St::Source;
     }
     ///State transition - sets the `source` field to Set
     pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSource<St> {}
     impl<St: State> State for SetSource<St> {
+        type Name = St::Name;
         type Branch = St::Branch;
         type Did = St::Did;
-        type Name = St::Name;
         type Source = Set<members::source>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `branch` field
         pub struct branch(());
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `source` field
         pub struct source(());
     }
@@ -238,9 +238,9 @@ where
 impl<S: BosStr, St> ForkSyncBuilder<S, St>
 where
     St: fork_sync_state::State,
+    St::Name: fork_sync_state::IsSet,
     St::Branch: fork_sync_state::IsSet,
     St::Did: fork_sync_state::IsSet,
-    St::Name: fork_sync_state::IsSet,
     St::Source: fork_sync_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs b/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs
index d80c6b05..6eda593b 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/get_default_branch.rs
@@ -259,51 +259,51 @@ pub mod signature_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Email;
-        type When;
         type Name;
+        type When;
+        type Email;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Email = Unset;
-        type When = Unset;
         type Name = Unset;
+        type When = Unset;
+        type Email = Unset;
     }
-    ///State transition - sets the `email` field to Set
-    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEmail<St> {}
-    impl<St: State> State for SetEmail<St> {
-        type Email = Set<members::email>;
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
         type When = St::When;
-        type Name = St::Name;
+        type Email = St::Email;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Email = St::Email;
-        type When = Set<members::when>;
         type Name = St::Name;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
+        type When = Set<members::when>;
         type Email = St::Email;
+    }
+    ///State transition - sets the `email` field to Set
+    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEmail<St> {}
+    impl<St: State> State for SetEmail<St> {
+        type Name = St::Name;
         type When = St::When;
-        type Name = Set<members::name>;
+        type Email = Set<members::email>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `email` field
-        pub struct email(());
-        ///Marker type for the `when` field
-        pub struct when(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `when` field
+        pub struct when(());
+        ///Marker type for the `email` field
+        pub struct email(());
     }
 }
 
@@ -392,9 +392,9 @@ where
 impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
-    St::Email: signature_state::IsSet,
-    St::When: signature_state::IsSet,
     St::Name: signature_state::IsSet,
+    St::When: signature_state::IsSet,
+    St::Email: signature_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Signature<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/hidden_ref.rs b/crates/jacquard-api/src/sh_tangled/repo/hidden_ref.rs
index dc45814a..88faafa3 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/hidden_ref.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/hidden_ref.rs
@@ -84,51 +84,51 @@ pub mod hidden_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type RemoteRef;
-        type Repo;
         type ForkRef;
+        type Repo;
+        type RemoteRef;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type RemoteRef = Unset;
-        type Repo = Unset;
         type ForkRef = Unset;
+        type Repo = Unset;
+        type RemoteRef = Unset;
     }
-    ///State transition - sets the `remote_ref` field to Set
-    pub struct SetRemoteRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRemoteRef<St> {}
-    impl<St: State> State for SetRemoteRef<St> {
-        type RemoteRef = Set<members::remote_ref>;
+    ///State transition - sets the `fork_ref` field to Set
+    pub struct SetForkRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetForkRef<St> {}
+    impl<St: State> State for SetForkRef<St> {
+        type ForkRef = Set<members::fork_ref>;
         type Repo = St::Repo;
-        type ForkRef = St::ForkRef;
+        type RemoteRef = St::RemoteRef;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
-        type RemoteRef = St::RemoteRef;
-        type Repo = Set<members::repo>;
         type ForkRef = St::ForkRef;
-    }
-    ///State transition - sets the `fork_ref` field to Set
-    pub struct SetForkRef<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetForkRef<St> {}
-    impl<St: State> State for SetForkRef<St> {
+        type Repo = Set<members::repo>;
         type RemoteRef = St::RemoteRef;
+    }
+    ///State transition - sets the `remote_ref` field to Set
+    pub struct SetRemoteRef<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRemoteRef<St> {}
+    impl<St: State> State for SetRemoteRef<St> {
+        type ForkRef = St::ForkRef;
         type Repo = St::Repo;
-        type ForkRef = Set<members::fork_ref>;
+        type RemoteRef = Set<members::remote_ref>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `remote_ref` field
-        pub struct remote_ref(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `fork_ref` field
         pub struct fork_ref(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
+        ///Marker type for the `remote_ref` field
+        pub struct remote_ref(());
     }
 }
 
@@ -217,9 +217,9 @@ where
 impl<S: BosStr, St> HiddenRefBuilder<S, St>
 where
     St: hidden_ref_state::State,
-    St::RemoteRef: hidden_ref_state::IsSet,
-    St::Repo: hidden_ref_state::IsSet,
     St::ForkRef: hidden_ref_state::IsSet,
+    St::Repo: hidden_ref_state::IsSet,
+    St::RemoteRef: hidden_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> HiddenRef<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/issue.rs b/crates/jacquard-api/src/sh_tangled/repo/issue.rs
index 6e6bc23a..f1617dfb 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/issue.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/issue.rs
@@ -122,51 +122,51 @@ pub mod issue_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
-        type CreatedAt;
         type Title;
+        type CreatedAt;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
-        type CreatedAt = Unset;
         type Title = Unset;
+        type CreatedAt = Unset;
+        type Repo = Unset;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
+        type Repo = St::Repo;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Repo = St::Repo;
-        type CreatedAt = Set<members::created_at>;
         type Title = St::Title;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
+        type CreatedAt = Set<members::created_at>;
         type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Title = St::Title;
         type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -301,9 +301,9 @@ where
 impl<S: BosStr, St> IssueBuilder<S, St>
 where
     St: issue_state::State,
-    St::Repo: issue_state::IsSet,
-    St::CreatedAt: issue_state::IsSet,
     St::Title: issue_state::IsSet,
+    St::CreatedAt: issue_state::IsSet,
+    St::Repo: issue_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Issue<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs b/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs
index 96d3f610..4b9148c6 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/issue/comment.rs
@@ -119,50 +119,50 @@ pub mod comment_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Body;
         type Issue;
+        type Body;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Body = Unset;
         type Issue = Unset;
+        type Body = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Body = St::Body;
-        type Issue = St::Issue;
-    }
-    ///State transition - sets the `body` field to Set
-    pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBody<St> {}
-    impl<St: State> State for SetBody<St> {
-        type CreatedAt = St::CreatedAt;
-        type Body = Set<members::body>;
         type Issue = St::Issue;
+        type Body = St::Body;
     }
     ///State transition - sets the `issue` field to Set
     pub struct SetIssue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIssue<St> {}
     impl<St: State> State for SetIssue<St> {
         type CreatedAt = St::CreatedAt;
-        type Body = St::Body;
         type Issue = Set<members::issue>;
+        type Body = St::Body;
+    }
+    ///State transition - sets the `body` field to Set
+    pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBody<St> {}
+    impl<St: State> State for SetBody<St> {
+        type CreatedAt = St::CreatedAt;
+        type Issue = St::Issue;
+        type Body = Set<members::body>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `body` field
-        pub struct body(());
         ///Marker type for the `issue` field
         pub struct issue(());
+        ///Marker type for the `body` field
+        pub struct body(());
     }
 }
 
@@ -298,8 +298,8 @@ impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
     St::CreatedAt: comment_state::IsSet,
-    St::Body: comment_state::IsSet,
     St::Issue: comment_state::IsSet,
+    St::Body: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/languages.rs b/crates/jacquard-api/src/sh_tangled/repo/languages.rs
index 10bb0fa9..042dd700 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/languages.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/languages.rs
@@ -187,49 +187,49 @@ pub mod language_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Size;
         type Percentage;
+        type Size;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Size = Unset;
         type Percentage = Unset;
+        type Size = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `size` field to Set
-    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSize<St> {}
-    impl<St: State> State for SetSize<St> {
-        type Size = Set<members::size>;
-        type Percentage = St::Percentage;
-        type Name = St::Name;
-    }
     ///State transition - sets the `percentage` field to Set
     pub struct SetPercentage<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPercentage<St> {}
     impl<St: State> State for SetPercentage<St> {
-        type Size = St::Size;
         type Percentage = Set<members::percentage>;
+        type Size = St::Size;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `size` field to Set
+    pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSize<St> {}
+    impl<St: State> State for SetSize<St> {
+        type Percentage = St::Percentage;
+        type Size = Set<members::size>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Size = St::Size;
         type Percentage = St::Percentage;
+        type Size = St::Size;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `size` field
-        pub struct size(());
         ///Marker type for the `percentage` field
         pub struct percentage(());
+        ///Marker type for the `size` field
+        pub struct size(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -366,8 +366,8 @@ where
 impl<S: BosStr, St> LanguageBuilder<S, St>
 where
     St: language_state::State,
-    St::Size: language_state::IsSet,
     St::Percentage: language_state::IsSet,
+    St::Size: language_state::IsSet,
     St::Name: language_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs b/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs
index 89085b2b..dd919798 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/list_secrets.rs
@@ -213,65 +213,65 @@ pub mod secret_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Key;
         type CreatedAt;
+        type Repo;
         type CreatedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Key = Unset;
         type CreatedAt = Unset;
+        type Repo = Unset;
         type CreatedBy = Unset;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Key = St::Key;
-        type CreatedAt = St::CreatedAt;
-        type CreatedBy = St::CreatedBy;
-    }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Repo = St::Repo;
         type Key = Set<members::key>;
         type CreatedAt = St::CreatedAt;
+        type Repo = St::Repo;
         type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Repo = St::Repo;
         type Key = St::Key;
         type CreatedAt = Set<members::created_at>;
+        type Repo = St::Repo;
+        type CreatedBy = St::CreatedBy;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Key = St::Key;
+        type CreatedAt = St::CreatedAt;
+        type Repo = Set<members::repo>;
         type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `created_by` field to Set
     pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
     impl<St: State> State for SetCreatedBy<St> {
-        type Repo = St::Repo;
         type Key = St::Key;
         type CreatedAt = St::CreatedAt;
+        type Repo = St::Repo;
         type CreatedBy = Set<members::created_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `key` field
         pub struct key(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
     }
@@ -381,9 +381,9 @@ where
 impl<S: BosStr, St> SecretBuilder<S, St>
 where
     St: secret_state::State,
-    St::Repo: secret_state::IsSet,
     St::Key: secret_state::IsSet,
     St::CreatedAt: secret_state::IsSet,
+    St::Repo: secret_state::IsSet,
     St::CreatedBy: secret_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/repo/merge.rs b/crates/jacquard-api/src/sh_tangled/repo/merge.rs
index 4e7afca2..d338a110 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/merge.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/merge.rs
@@ -82,67 +82,67 @@ pub mod merge_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Branch;
+        type Patch;
         type Did;
+        type Branch;
         type Name;
-        type Patch;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Branch = Unset;
+        type Patch = Unset;
         type Did = Unset;
+        type Branch = Unset;
         type Name = Unset;
-        type Patch = Unset;
     }
-    ///State transition - sets the `branch` field to Set
-    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBranch<St> {}
-    impl<St: State> State for SetBranch<St> {
-        type Branch = Set<members::branch>;
+    ///State transition - sets the `patch` field to Set
+    pub struct SetPatch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPatch<St> {}
+    impl<St: State> State for SetPatch<St> {
+        type Patch = Set<members::patch>;
         type Did = St::Did;
+        type Branch = St::Branch;
         type Name = St::Name;
-        type Patch = St::Patch;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Branch = St::Branch;
+        type Patch = St::Patch;
         type Did = Set<members::did>;
+        type Branch = St::Branch;
         type Name = St::Name;
+    }
+    ///State transition - sets the `branch` field to Set
+    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBranch<St> {}
+    impl<St: State> State for SetBranch<St> {
         type Patch = St::Patch;
+        type Did = St::Did;
+        type Branch = Set<members::branch>;
+        type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Branch = St::Branch;
-        type Did = St::Did;
-        type Name = Set<members::name>;
         type Patch = St::Patch;
-    }
-    ///State transition - sets the `patch` field to Set
-    pub struct SetPatch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPatch<St> {}
-    impl<St: State> State for SetPatch<St> {
-        type Branch = St::Branch;
         type Did = St::Did;
-        type Name = St::Name;
-        type Patch = Set<members::patch>;
+        type Branch = St::Branch;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `branch` field
-        pub struct branch(());
+        ///Marker type for the `patch` field
+        pub struct patch(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `branch` field
+        pub struct branch(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `patch` field
-        pub struct patch(());
     }
 }
 
@@ -311,10 +311,10 @@ where
 impl<S: BosStr, St> MergeBuilder<S, St>
 where
     St: merge_state::State,
-    St::Branch: merge_state::IsSet,
+    St::Patch: merge_state::IsSet,
     St::Did: merge_state::IsSet,
+    St::Branch: merge_state::IsSet,
     St::Name: merge_state::IsSet,
-    St::Patch: merge_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Merge<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs b/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs
index f6771648..45432126 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/merge_check.rs
@@ -241,8 +241,8 @@ pub mod merge_check_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Branch;
         type Patch;
+        type Branch;
         type Name;
         type Did;
     }
@@ -250,26 +250,26 @@ pub mod merge_check_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Branch = Unset;
         type Patch = Unset;
+        type Branch = Unset;
         type Name = Unset;
         type Did = Unset;
     }
-    ///State transition - sets the `branch` field to Set
-    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBranch<St> {}
-    impl<St: State> State for SetBranch<St> {
-        type Branch = Set<members::branch>;
-        type Patch = St::Patch;
-        type Name = St::Name;
-        type Did = St::Did;
-    }
     ///State transition - sets the `patch` field to Set
     pub struct SetPatch<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPatch<St> {}
     impl<St: State> State for SetPatch<St> {
-        type Branch = St::Branch;
         type Patch = Set<members::patch>;
+        type Branch = St::Branch;
+        type Name = St::Name;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `branch` field to Set
+    pub struct SetBranch<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBranch<St> {}
+    impl<St: State> State for SetBranch<St> {
+        type Patch = St::Patch;
+        type Branch = Set<members::branch>;
         type Name = St::Name;
         type Did = St::Did;
     }
@@ -277,8 +277,8 @@ pub mod merge_check_state {
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Branch = St::Branch;
         type Patch = St::Patch;
+        type Branch = St::Branch;
         type Name = Set<members::name>;
         type Did = St::Did;
     }
@@ -286,18 +286,18 @@ pub mod merge_check_state {
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Branch = St::Branch;
         type Patch = St::Patch;
+        type Branch = St::Branch;
         type Name = St::Name;
         type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `branch` field
-        pub struct branch(());
         ///Marker type for the `patch` field
         pub struct patch(());
+        ///Marker type for the `branch` field
+        pub struct branch(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `did` field
@@ -409,8 +409,8 @@ where
 impl<S: BosStr, St> MergeCheckBuilder<S, St>
 where
     St: merge_check_state::State,
-    St::Branch: merge_check_state::IsSet,
     St::Patch: merge_check_state::IsSet,
+    St::Branch: merge_check_state::IsSet,
     St::Name: merge_check_state::IsSet,
     St::Did: merge_check_state::IsSet,
 {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/pull.rs b/crates/jacquard-api/src/sh_tangled/repo/pull.rs
index 28dcc2b7..5c08334c 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/pull.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/pull.rs
@@ -232,67 +232,67 @@ pub mod pull_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Title;
-        type PatchBlob;
         type Target;
+        type PatchBlob;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Title = Unset;
-        type PatchBlob = Unset;
         type Target = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
-        type PatchBlob = St::PatchBlob;
-        type Target = St::Target;
+        type PatchBlob = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = Set<members::title>;
-        type PatchBlob = St::PatchBlob;
         type Target = St::Target;
+        type PatchBlob = St::PatchBlob;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `target` field to Set
+    pub struct SetTarget<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTarget<St> {}
+    impl<St: State> State for SetTarget<St> {
+        type Title = St::Title;
+        type Target = Set<members::target>;
+        type PatchBlob = St::PatchBlob;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `patch_blob` field to Set
     pub struct SetPatchBlob<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPatchBlob<St> {}
     impl<St: State> State for SetPatchBlob<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = St::Title;
-        type PatchBlob = Set<members::patch_blob>;
         type Target = St::Target;
-    }
-    ///State transition - sets the `target` field to Set
-    pub struct SetTarget<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTarget<St> {}
-    impl<St: State> State for SetTarget<St> {
+        type PatchBlob = Set<members::patch_blob>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Title = St::Title;
+        type Target = St::Target;
         type PatchBlob = St::PatchBlob;
-        type Target = Set<members::target>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `patch_blob` field
-        pub struct patch_blob(());
         ///Marker type for the `target` field
         pub struct target(());
+        ///Marker type for the `patch_blob` field
+        pub struct patch_blob(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -475,10 +475,10 @@ where
 impl<S: BosStr, St> PullBuilder<S, St>
 where
     St: pull_state::State,
-    St::CreatedAt: pull_state::IsSet,
     St::Title: pull_state::IsSet,
-    St::PatchBlob: pull_state::IsSet,
     St::Target: pull_state::IsSet,
+    St::PatchBlob: pull_state::IsSet,
+    St::CreatedAt: pull_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Pull<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs b/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs
index 4b1378c7..382c43f1 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/pull/comment.rs
@@ -117,50 +117,50 @@ pub mod comment_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Body;
         type Pull;
+        type Body;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Body = Unset;
         type Pull = Unset;
+        type Body = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Body = St::Body;
-        type Pull = St::Pull;
-    }
-    ///State transition - sets the `body` field to Set
-    pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBody<St> {}
-    impl<St: State> State for SetBody<St> {
-        type CreatedAt = St::CreatedAt;
-        type Body = Set<members::body>;
         type Pull = St::Pull;
+        type Body = St::Body;
     }
     ///State transition - sets the `pull` field to Set
     pub struct SetPull<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPull<St> {}
     impl<St: State> State for SetPull<St> {
         type CreatedAt = St::CreatedAt;
-        type Body = St::Body;
         type Pull = Set<members::pull>;
+        type Body = St::Body;
+    }
+    ///State transition - sets the `body` field to Set
+    pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBody<St> {}
+    impl<St: State> State for SetBody<St> {
+        type CreatedAt = St::CreatedAt;
+        type Pull = St::Pull;
+        type Body = Set<members::body>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `body` field
-        pub struct body(());
         ///Marker type for the `pull` field
         pub struct pull(());
+        ///Marker type for the `body` field
+        pub struct body(());
     }
 }
 
@@ -282,8 +282,8 @@ impl<S: BosStr, St> CommentBuilder<S, St>
 where
     St: comment_state::State,
     St::CreatedAt: comment_state::IsSet,
-    St::Body: comment_state::IsSet,
     St::Pull: comment_state::IsSet,
+    St::Body: comment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Comment<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/remove_secret.rs b/crates/jacquard-api/src/sh_tangled/repo/remove_secret.rs
index 2be5282a..16792282 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/remove_secret.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/remove_secret.rs
@@ -64,37 +64,37 @@ pub mod remove_secret_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Key;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Key = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Key = St::Key;
+        type Repo = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetKey<St> {}
     impl<St: State> State for SetKey<St> {
-        type Repo = St::Repo;
         type Key = Set<members::key>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Key = St::Key;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `key` field
         pub struct key(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -164,8 +164,8 @@ where
 impl<S: BosStr, St> RemoveSecretBuilder<S, St>
 where
     St: remove_secret_state::State,
-    St::Repo: remove_secret_state::IsSet,
     St::Key: remove_secret_state::IsSet,
+    St::Repo: remove_secret_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RemoveSecret<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/repo/tree.rs b/crates/jacquard-api/src/sh_tangled/repo/tree.rs
index 83b3ef62..45778473 100644
--- a/crates/jacquard-api/src/sh_tangled/repo/tree.rs
+++ b/crates/jacquard-api/src/sh_tangled/repo/tree.rs
@@ -284,51 +284,51 @@ pub mod last_commit_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Message;
         type When;
         type Hash;
-        type Message;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Message = Unset;
         type When = Unset;
         type Hash = Unset;
-        type Message = Unset;
+    }
+    ///State transition - sets the `message` field to Set
+    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMessage<St> {}
+    impl<St: State> State for SetMessage<St> {
+        type Message = Set<members::message>;
+        type When = St::When;
+        type Hash = St::Hash;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
+        type Message = St::Message;
         type When = Set<members::when>;
         type Hash = St::Hash;
-        type Message = St::Message;
     }
     ///State transition - sets the `hash` field to Set
     pub struct SetHash<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHash<St> {}
     impl<St: State> State for SetHash<St> {
-        type When = St::When;
-        type Hash = Set<members::hash>;
         type Message = St::Message;
-    }
-    ///State transition - sets the `message` field to Set
-    pub struct SetMessage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMessage<St> {}
-    impl<St: State> State for SetMessage<St> {
         type When = St::When;
-        type Hash = St::Hash;
-        type Message = Set<members::message>;
+        type Hash = Set<members::hash>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `message` field
+        pub struct message(());
         ///Marker type for the `when` field
         pub struct when(());
         ///Marker type for the `hash` field
         pub struct hash(());
-        ///Marker type for the `message` field
-        pub struct message(());
     }
 }
 
@@ -430,9 +430,9 @@ where
 impl<S: BosStr, St> LastCommitBuilder<S, St>
 where
     St: last_commit_state::State,
+    St::Message: last_commit_state::IsSet,
     St::When: last_commit_state::IsSet,
     St::Hash: last_commit_state::IsSet,
-    St::Message: last_commit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LastCommit<S> {
@@ -843,51 +843,51 @@ pub mod signature_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Email;
         type When;
         type Name;
+        type Email;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Email = Unset;
         type When = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `email` field to Set
-    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEmail<St> {}
-    impl<St: State> State for SetEmail<St> {
-        type Email = Set<members::email>;
-        type When = St::When;
-        type Name = St::Name;
+        type Email = Unset;
     }
     ///State transition - sets the `when` field to Set
     pub struct SetWhen<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWhen<St> {}
     impl<St: State> State for SetWhen<St> {
-        type Email = St::Email;
         type When = Set<members::when>;
         type Name = St::Name;
+        type Email = St::Email;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Email = St::Email;
         type When = St::When;
         type Name = Set<members::name>;
+        type Email = St::Email;
+    }
+    ///State transition - sets the `email` field to Set
+    pub struct SetEmail<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEmail<St> {}
+    impl<St: State> State for SetEmail<St> {
+        type When = St::When;
+        type Name = St::Name;
+        type Email = Set<members::email>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `email` field
-        pub struct email(());
         ///Marker type for the `when` field
         pub struct when(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `email` field
+        pub struct email(());
     }
 }
 
@@ -976,9 +976,9 @@ where
 impl<S: BosStr, St> SignatureBuilder<S, St>
 where
     St: signature_state::State,
-    St::Email: signature_state::IsSet,
     St::When: signature_state::IsSet,
     St::Name: signature_state::IsSet,
+    St::Email: signature_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Signature<S> {
@@ -1013,49 +1013,49 @@ pub mod tree_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Mode;
         type Size;
+        type Mode;
         type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Mode = Unset;
         type Size = Unset;
+        type Mode = Unset;
         type Name = Unset;
     }
-    ///State transition - sets the `mode` field to Set
-    pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMode<St> {}
-    impl<St: State> State for SetMode<St> {
-        type Mode = Set<members::mode>;
-        type Size = St::Size;
-        type Name = St::Name;
-    }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type Mode = St::Mode;
         type Size = Set<members::size>;
+        type Mode = St::Mode;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `mode` field to Set
+    pub struct SetMode<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMode<St> {}
+    impl<St: State> State for SetMode<St> {
+        type Size = St::Size;
+        type Mode = Set<members::mode>;
         type Name = St::Name;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Mode = St::Mode;
         type Size = St::Size;
+        type Mode = St::Mode;
         type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `mode` field
-        pub struct mode(());
         ///Marker type for the `size` field
         pub struct size(());
+        ///Marker type for the `mode` field
+        pub struct mode(());
         ///Marker type for the `name` field
         pub struct name(());
     }
@@ -1159,8 +1159,8 @@ where
 impl<S: BosStr, St> TreeEntryBuilder<S, St>
 where
     St: tree_entry_state::State,
-    St::Mode: tree_entry_state::IsSet,
     St::Size: tree_entry_state::IsSet,
+    St::Mode: tree_entry_state::IsSet,
     St::Name: tree_entry_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/sh_tangled/spindle/member.rs b/crates/jacquard-api/src/sh_tangled/spindle/member.rs
index 7b00c6eb..e2c9fe78 100644
--- a/crates/jacquard-api/src/sh_tangled/spindle/member.rs
+++ b/crates/jacquard-api/src/sh_tangled/spindle/member.rs
@@ -113,51 +113,51 @@ pub mod member_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Subject;
         type Instance;
+        type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Subject = Unset;
         type Instance = Unset;
+        type Subject = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `instance` field to Set
+    pub struct SetInstance<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetInstance<St> {}
+    impl<St: State> State for SetInstance<St> {
+        type Instance = Set<members::instance>;
         type Subject = St::Subject;
-        type Instance = St::Instance;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
         type Instance = St::Instance;
-    }
-    ///State transition - sets the `instance` field to Set
-    pub struct SetInstance<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetInstance<St> {}
-    impl<St: State> State for SetInstance<St> {
+        type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Instance = St::Instance;
         type Subject = St::Subject;
-        type Instance = Set<members::instance>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `instance` field
         pub struct instance(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -246,9 +246,9 @@ where
 impl<S: BosStr, St> MemberBuilder<S, St>
 where
     St: member_state::State,
-    St::CreatedAt: member_state::IsSet,
-    St::Subject: member_state::IsSet,
     St::Instance: member_state::IsSet,
+    St::Subject: member_state::IsSet,
+    St::CreatedAt: member_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Member<S> {
diff --git a/crates/jacquard-api/src/sh_tangled/string.rs b/crates/jacquard-api/src/sh_tangled/string.rs
index bd85e937..3e41f083 100644
--- a/crates/jacquard-api/src/sh_tangled/string.rs
+++ b/crates/jacquard-api/src/sh_tangled/string.rs
@@ -165,67 +165,67 @@ pub mod tangled_string_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Description;
         type Contents;
-        type CreatedAt;
+        type Description;
         type Filename;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Description = Unset;
         type Contents = Unset;
-        type CreatedAt = Unset;
+        type Description = Unset;
         type Filename = Unset;
-    }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Description = Set<members::description>;
-        type Contents = St::Contents;
-        type CreatedAt = St::CreatedAt;
-        type Filename = St::Filename;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `contents` field to Set
     pub struct SetContents<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContents<St> {}
     impl<St: State> State for SetContents<St> {
-        type Description = St::Description;
         type Contents = Set<members::contents>;
-        type CreatedAt = St::CreatedAt;
+        type Description = St::Description;
         type Filename = St::Filename;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Description = St::Description;
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
         type Contents = St::Contents;
-        type CreatedAt = Set<members::created_at>;
+        type Description = Set<members::description>;
         type Filename = St::Filename;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `filename` field to Set
     pub struct SetFilename<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFilename<St> {}
     impl<St: State> State for SetFilename<St> {
-        type Description = St::Description;
         type Contents = St::Contents;
-        type CreatedAt = St::CreatedAt;
+        type Description = St::Description;
         type Filename = Set<members::filename>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Contents = St::Contents;
+        type Description = St::Description;
+        type Filename = St::Filename;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `contents` field
         pub struct contents(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `description` field
+        pub struct description(());
         ///Marker type for the `filename` field
         pub struct filename(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -333,10 +333,10 @@ where
 impl<S: BosStr, St> TangledStringBuilder<S, St>
 where
     St: tangled_string_state::State,
-    St::Description: tangled_string_state::IsSet,
     St::Contents: tangled_string_state::IsSet,
-    St::CreatedAt: tangled_string_state::IsSet,
+    St::Description: tangled_string_state::IsSet,
     St::Filename: tangled_string_state::IsSet,
+    St::CreatedAt: tangled_string_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TangledString<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/actor.rs b/crates/jacquard-api/src/sh_weaver/actor.rs
index f0613d26..c85bd0e1 100644
--- a/crates/jacquard-api/src/sh_weaver/actor.rs
+++ b/crates/jacquard-api/src/sh_weaver/actor.rs
@@ -1786,37 +1786,37 @@ pub mod profile_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Handle;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Handle = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Handle = St::Handle;
+        type Did = Unset;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
         type Handle = Set<members::handle>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Handle = St::Handle;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -2132,8 +2132,8 @@ impl<S: BosStr, St: profile_view_state::State> ProfileViewBuilder<S, St> {
 impl<S: BosStr, St> ProfileViewBuilder<S, St>
 where
     St: profile_view_state::State,
-    St::Did: profile_view_state::IsSet,
     St::Handle: profile_view_state::IsSet,
+    St::Did: profile_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileView<S> {
@@ -2198,37 +2198,37 @@ pub mod profile_view_basic_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Did;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Did = St::Did;
+        type Handle = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Handle = St::Handle;
         type Did = Set<members::did>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -2385,8 +2385,8 @@ impl<S: BosStr, St: profile_view_basic_state::State> ProfileViewBasicBuilder<S,
 impl<S: BosStr, St> ProfileViewBasicBuilder<S, St>
 where
     St: profile_view_basic_state::State,
-    St::Handle: profile_view_basic_state::IsSet,
     St::Did: profile_view_basic_state::IsSet,
+    St::Handle: profile_view_basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileViewBasic<S> {
@@ -2561,51 +2561,51 @@ pub mod tangled_profile_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Bluesky;
         type Did;
         type Handle;
-        type Bluesky;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Bluesky = Unset;
         type Did = Unset;
         type Handle = Unset;
-        type Bluesky = Unset;
+    }
+    ///State transition - sets the `bluesky` field to Set
+    pub struct SetBluesky<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBluesky<St> {}
+    impl<St: State> State for SetBluesky<St> {
+        type Bluesky = Set<members::bluesky>;
+        type Did = St::Did;
+        type Handle = St::Handle;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
+        type Bluesky = St::Bluesky;
         type Did = Set<members::did>;
         type Handle = St::Handle;
-        type Bluesky = St::Bluesky;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
-        type Handle = Set<members::handle>;
         type Bluesky = St::Bluesky;
-    }
-    ///State transition - sets the `bluesky` field to Set
-    pub struct SetBluesky<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBluesky<St> {}
-    impl<St: State> State for SetBluesky<St> {
         type Did = St::Did;
-        type Handle = St::Handle;
-        type Bluesky = Set<members::bluesky>;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `bluesky` field
+        pub struct bluesky(());
         ///Marker type for the `did` field
         pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
-        ///Marker type for the `bluesky` field
-        pub struct bluesky(());
     }
 }
 
@@ -2771,9 +2771,9 @@ impl<S: BosStr, St: tangled_profile_view_state::State> TangledProfileViewBuilder
 impl<S: BosStr, St> TangledProfileViewBuilder<S, St>
 where
     St: tangled_profile_view_state::State,
+    St::Bluesky: tangled_profile_view_state::IsSet,
     St::Did: tangled_profile_view_state::IsSet,
     St::Handle: tangled_profile_view_state::IsSet,
-    St::Bluesky: tangled_profile_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TangledProfileView<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/collab.rs b/crates/jacquard-api/src/sh_weaver/collab.rs
index dbf9fff3..9aec3142 100644
--- a/crates/jacquard-api/src/sh_weaver/collab.rs
+++ b/crates/jacquard-api/src/sh_weaver/collab.rs
@@ -928,51 +928,51 @@ pub mod collaboration_state_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Status;
         type Resource;
         type Participants;
+        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Status = Unset;
         type Resource = Unset;
         type Participants = Unset;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
-        type Status = Set<members::status>;
-        type Resource = St::Resource;
-        type Participants = St::Participants;
+        type Status = Unset;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
-        type Status = St::Status;
         type Resource = Set<members::resource>;
         type Participants = St::Participants;
+        type Status = St::Status;
     }
     ///State transition - sets the `participants` field to Set
     pub struct SetParticipants<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetParticipants<St> {}
     impl<St: State> State for SetParticipants<St> {
-        type Status = St::Status;
         type Resource = St::Resource;
         type Participants = Set<members::participants>;
+        type Status = St::Status;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Resource = St::Resource;
+        type Participants = St::Participants;
+        type Status = Set<members::status>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `status` field
-        pub struct status(());
         ///Marker type for the `resource` field
         pub struct resource(());
         ///Marker type for the `participants` field
         pub struct participants(());
+        ///Marker type for the `status` field
+        pub struct status(());
     }
 }
 
@@ -1261,9 +1261,9 @@ where
 impl<S: BosStr, St> CollaborationStateViewBuilder<S, St>
 where
     St: collaboration_state_view_state::State,
-    St::Status: collaboration_state_view_state::IsSet,
     St::Resource: collaboration_state_view_state::IsSet,
     St::Participants: collaboration_state_view_state::IsSet,
+    St::Status: collaboration_state_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollaborationStateView<S> {
@@ -1841,65 +1841,65 @@ pub mod former_collaborator_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type User;
         type WasActiveUntil;
         type EndReason;
-        type User;
         type WasActiveFrom;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type User = Unset;
         type WasActiveUntil = Unset;
         type EndReason = Unset;
-        type User = Unset;
         type WasActiveFrom = Unset;
     }
+    ///State transition - sets the `user` field to Set
+    pub struct SetUser<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUser<St> {}
+    impl<St: State> State for SetUser<St> {
+        type User = Set<members::user>;
+        type WasActiveUntil = St::WasActiveUntil;
+        type EndReason = St::EndReason;
+        type WasActiveFrom = St::WasActiveFrom;
+    }
     ///State transition - sets the `was_active_until` field to Set
     pub struct SetWasActiveUntil<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWasActiveUntil<St> {}
     impl<St: State> State for SetWasActiveUntil<St> {
+        type User = St::User;
         type WasActiveUntil = Set<members::was_active_until>;
         type EndReason = St::EndReason;
-        type User = St::User;
         type WasActiveFrom = St::WasActiveFrom;
     }
     ///State transition - sets the `end_reason` field to Set
     pub struct SetEndReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEndReason<St> {}
     impl<St: State> State for SetEndReason<St> {
-        type WasActiveUntil = St::WasActiveUntil;
-        type EndReason = Set<members::end_reason>;
         type User = St::User;
-        type WasActiveFrom = St::WasActiveFrom;
-    }
-    ///State transition - sets the `user` field to Set
-    pub struct SetUser<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUser<St> {}
-    impl<St: State> State for SetUser<St> {
         type WasActiveUntil = St::WasActiveUntil;
-        type EndReason = St::EndReason;
-        type User = Set<members::user>;
+        type EndReason = Set<members::end_reason>;
         type WasActiveFrom = St::WasActiveFrom;
     }
     ///State transition - sets the `was_active_from` field to Set
     pub struct SetWasActiveFrom<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWasActiveFrom<St> {}
     impl<St: State> State for SetWasActiveFrom<St> {
+        type User = St::User;
         type WasActiveUntil = St::WasActiveUntil;
         type EndReason = St::EndReason;
-        type User = St::User;
         type WasActiveFrom = Set<members::was_active_from>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `user` field
+        pub struct user(());
         ///Marker type for the `was_active_until` field
         pub struct was_active_until(());
         ///Marker type for the `end_reason` field
         pub struct end_reason(());
-        ///Marker type for the `user` field
-        pub struct user(());
         ///Marker type for the `was_active_from` field
         pub struct was_active_from(());
     }
@@ -2080,9 +2080,9 @@ where
 impl<S: BosStr, St> FormerCollaboratorViewBuilder<S, St>
 where
     St: former_collaborator_view_state::State,
+    St::User: former_collaborator_view_state::IsSet,
     St::WasActiveUntil: former_collaborator_view_state::IsSet,
     St::EndReason: former_collaborator_view_state::IsSet,
-    St::User: former_collaborator_view_state::IsSet,
     St::WasActiveFrom: former_collaborator_view_state::IsSet,
 {
     /// Build the final struct.
@@ -2126,127 +2126,127 @@ pub mod invite_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Status;
+        type Inviter;
         type Invitee;
+        type Uri;
         type Resource;
         type CreatedAt;
-        type Status;
-        type Uri;
         type Cid;
-        type Inviter;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Status = Unset;
+        type Inviter = Unset;
         type Invitee = Unset;
+        type Uri = Unset;
         type Resource = Unset;
         type CreatedAt = Unset;
-        type Status = Unset;
-        type Uri = Unset;
         type Cid = Unset;
-        type Inviter = Unset;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Status = Set<members::status>;
+        type Inviter = St::Inviter;
+        type Invitee = St::Invitee;
+        type Uri = St::Uri;
+        type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `inviter` field to Set
+    pub struct SetInviter<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetInviter<St> {}
+    impl<St: State> State for SetInviter<St> {
+        type Status = St::Status;
+        type Inviter = Set<members::inviter>;
+        type Invitee = St::Invitee;
+        type Uri = St::Uri;
+        type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `invitee` field to Set
     pub struct SetInvitee<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetInvitee<St> {}
     impl<St: State> State for SetInvitee<St> {
+        type Status = St::Status;
+        type Inviter = St::Inviter;
         type Invitee = Set<members::invitee>;
+        type Uri = St::Uri;
         type Resource = St::Resource;
         type CreatedAt = St::CreatedAt;
-        type Status = St::Status;
-        type Uri = St::Uri;
         type Cid = St::Cid;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Status = St::Status;
         type Inviter = St::Inviter;
+        type Invitee = St::Invitee;
+        type Uri = Set<members::uri>;
+        type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
+        type Status = St::Status;
+        type Inviter = St::Inviter;
         type Invitee = St::Invitee;
+        type Uri = St::Uri;
         type Resource = Set<members::resource>;
         type CreatedAt = St::CreatedAt;
-        type Status = St::Status;
-        type Uri = St::Uri;
         type Cid = St::Cid;
-        type Inviter = St::Inviter;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Invitee = St::Invitee;
-        type Resource = St::Resource;
-        type CreatedAt = Set<members::created_at>;
         type Status = St::Status;
-        type Uri = St::Uri;
-        type Cid = St::Cid;
         type Inviter = St::Inviter;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
         type Invitee = St::Invitee;
-        type Resource = St::Resource;
-        type CreatedAt = St::CreatedAt;
-        type Status = Set<members::status>;
         type Uri = St::Uri;
-        type Cid = St::Cid;
-        type Inviter = St::Inviter;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Invitee = St::Invitee;
         type Resource = St::Resource;
-        type CreatedAt = St::CreatedAt;
-        type Status = St::Status;
-        type Uri = Set<members::uri>;
+        type CreatedAt = Set<members::created_at>;
         type Cid = St::Cid;
-        type Inviter = St::Inviter;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Invitee = St::Invitee;
-        type Resource = St::Resource;
-        type CreatedAt = St::CreatedAt;
         type Status = St::Status;
-        type Uri = St::Uri;
-        type Cid = Set<members::cid>;
         type Inviter = St::Inviter;
-    }
-    ///State transition - sets the `inviter` field to Set
-    pub struct SetInviter<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetInviter<St> {}
-    impl<St: State> State for SetInviter<St> {
         type Invitee = St::Invitee;
+        type Uri = St::Uri;
         type Resource = St::Resource;
         type CreatedAt = St::CreatedAt;
-        type Status = St::Status;
-        type Uri = St::Uri;
-        type Cid = St::Cid;
-        type Inviter = Set<members::inviter>;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `status` field
+        pub struct status(());
+        ///Marker type for the `inviter` field
+        pub struct inviter(());
         ///Marker type for the `invitee` field
         pub struct invitee(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `resource` field
         pub struct resource(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `status` field
-        pub struct status(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `inviter` field
-        pub struct inviter(());
     }
 }
 
@@ -2517,13 +2517,13 @@ where
 impl<S: BosStr, St> InviteViewBuilder<S, St>
 where
     St: invite_view_state::State,
+    St::Status: invite_view_state::IsSet,
+    St::Inviter: invite_view_state::IsSet,
     St::Invitee: invite_view_state::IsSet,
+    St::Uri: invite_view_state::IsSet,
     St::Resource: invite_view_state::IsSet,
     St::CreatedAt: invite_view_state::IsSet,
-    St::Status: invite_view_state::IsSet,
-    St::Uri: invite_view_state::IsSet,
     St::Cid: invite_view_state::IsSet,
-    St::Inviter: invite_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> InviteView<S> {
@@ -2578,51 +2578,51 @@ pub mod participant_state_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Status;
         type User;
         type Role;
-        type Status;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Status = Unset;
         type User = Unset;
         type Role = Unset;
-        type Status = Unset;
+    }
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type Status = Set<members::status>;
+        type User = St::User;
+        type Role = St::Role;
     }
     ///State transition - sets the `user` field to Set
     pub struct SetUser<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUser<St> {}
     impl<St: State> State for SetUser<St> {
+        type Status = St::Status;
         type User = Set<members::user>;
         type Role = St::Role;
-        type Status = St::Status;
     }
     ///State transition - sets the `role` field to Set
     pub struct SetRole<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRole<St> {}
     impl<St: State> State for SetRole<St> {
-        type User = St::User;
-        type Role = Set<members::role>;
         type Status = St::Status;
-    }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
         type User = St::User;
-        type Role = St::Role;
-        type Status = Set<members::status>;
+        type Role = Set<members::role>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `status` field
+        pub struct status(());
         ///Marker type for the `user` field
         pub struct user(());
         ///Marker type for the `role` field
         pub struct role(());
-        ///Marker type for the `status` field
-        pub struct status(());
     }
 }
 
@@ -2860,9 +2860,9 @@ impl<
 impl<S: BosStr, St> ParticipantStateViewBuilder<S, St>
 where
     St: participant_state_view_state::State,
+    St::Status: participant_state_view_state::IsSet,
     St::User: participant_state_view_state::IsSet,
     St::Role: participant_state_view_state::IsSet,
-    St::Status: participant_state_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ParticipantStateView<S> {
@@ -2914,84 +2914,84 @@ pub mod session_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type NodeId;
-        type CreatedAt;
         type Uri;
         type User;
         type Resource;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type NodeId = Unset;
-        type CreatedAt = Unset;
         type Uri = Unset;
         type User = Unset;
         type Resource = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `node_id` field to Set
     pub struct SetNodeId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNodeId<St> {}
     impl<St: State> State for SetNodeId<St> {
         type NodeId = Set<members::node_id>;
-        type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
-        type User = St::User;
-        type Resource = St::Resource;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type NodeId = St::NodeId;
-        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
         type User = St::User;
         type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type NodeId = St::NodeId;
-        type CreatedAt = St::CreatedAt;
         type Uri = Set<members::uri>;
         type User = St::User;
         type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `user` field to Set
     pub struct SetUser<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUser<St> {}
     impl<St: State> State for SetUser<St> {
         type NodeId = St::NodeId;
-        type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
         type User = Set<members::user>;
         type Resource = St::Resource;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
         type NodeId = St::NodeId;
-        type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
         type User = St::User;
         type Resource = Set<members::resource>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type NodeId = St::NodeId;
+        type Uri = St::Uri;
+        type User = St::User;
+        type Resource = St::Resource;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `node_id` field
         pub struct node_id(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `user` field
         pub struct user(());
         ///Marker type for the `resource` field
         pub struct resource(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -3153,10 +3153,10 @@ impl<S: BosStr, St> SessionViewBuilder<S, St>
 where
     St: session_view_state::State,
     St::NodeId: session_view_state::IsSet,
-    St::CreatedAt: session_view_state::IsSet,
     St::Uri: session_view_state::IsSet,
     St::User: session_view_state::IsSet,
     St::Resource: session_view_state::IsSet,
+    St::CreatedAt: session_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SessionView<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/collab/accept.rs b/crates/jacquard-api/src/sh_weaver/collab/accept.rs
index d9981b4c..6981fa0d 100644
--- a/crates/jacquard-api/src/sh_weaver/collab/accept.rs
+++ b/crates/jacquard-api/src/sh_weaver/collab/accept.rs
@@ -116,51 +116,51 @@ pub mod accept_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Invite;
         type CreatedAt;
         type Resource;
+        type Invite;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Invite = Unset;
         type CreatedAt = Unset;
         type Resource = Unset;
-    }
-    ///State transition - sets the `invite` field to Set
-    pub struct SetInvite<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetInvite<St> {}
-    impl<St: State> State for SetInvite<St> {
-        type Invite = Set<members::invite>;
-        type CreatedAt = St::CreatedAt;
-        type Resource = St::Resource;
+        type Invite = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Invite = St::Invite;
         type CreatedAt = Set<members::created_at>;
         type Resource = St::Resource;
+        type Invite = St::Invite;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
-        type Invite = St::Invite;
         type CreatedAt = St::CreatedAt;
         type Resource = Set<members::resource>;
+        type Invite = St::Invite;
+    }
+    ///State transition - sets the `invite` field to Set
+    pub struct SetInvite<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetInvite<St> {}
+    impl<St: State> State for SetInvite<St> {
+        type CreatedAt = St::CreatedAt;
+        type Resource = St::Resource;
+        type Invite = Set<members::invite>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `invite` field
-        pub struct invite(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `resource` field
         pub struct resource(());
+        ///Marker type for the `invite` field
+        pub struct invite(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> AcceptBuilder<S, St>
 where
     St: accept_state::State,
-    St::Invite: accept_state::IsSet,
     St::CreatedAt: accept_state::IsSet,
     St::Resource: accept_state::IsSet,
+    St::Invite: accept_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Accept<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/collab/invite.rs b/crates/jacquard-api/src/sh_weaver/collab/invite.rs
index b5793b20..86f4d493 100644
--- a/crates/jacquard-api/src/sh_weaver/collab/invite.rs
+++ b/crates/jacquard-api/src/sh_weaver/collab/invite.rs
@@ -230,50 +230,50 @@ pub mod invite_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Resource;
-        type CreatedAt;
         type Invitee;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Resource = Unset;
-        type CreatedAt = Unset;
         type Invitee = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
         type Resource = Set<members::resource>;
-        type CreatedAt = St::CreatedAt;
-        type Invitee = St::Invitee;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Resource = St::Resource;
-        type CreatedAt = Set<members::created_at>;
         type Invitee = St::Invitee;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `invitee` field to Set
     pub struct SetInvitee<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetInvitee<St> {}
     impl<St: State> State for SetInvitee<St> {
         type Resource = St::Resource;
-        type CreatedAt = St::CreatedAt;
         type Invitee = Set<members::invitee>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Resource = St::Resource;
+        type Invitee = St::Invitee;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `resource` field
         pub struct resource(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `invitee` field
         pub struct invitee(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -409,8 +409,8 @@ impl<S: BosStr, St> InviteBuilder<S, St>
 where
     St: invite_state::State,
     St::Resource: invite_state::IsSet,
-    St::CreatedAt: invite_state::IsSet,
     St::Invitee: invite_state::IsSet,
+    St::CreatedAt: invite_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Invite<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/collab/session.rs b/crates/jacquard-api/src/sh_weaver/collab/session.rs
index 344f98a7..661c5b6f 100644
--- a/crates/jacquard-api/src/sh_weaver/collab/session.rs
+++ b/crates/jacquard-api/src/sh_weaver/collab/session.rs
@@ -122,51 +122,51 @@ pub mod session_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type NodeId;
         type CreatedAt;
         type Resource;
+        type NodeId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type NodeId = Unset;
         type CreatedAt = Unset;
         type Resource = Unset;
-    }
-    ///State transition - sets the `node_id` field to Set
-    pub struct SetNodeId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNodeId<St> {}
-    impl<St: State> State for SetNodeId<St> {
-        type NodeId = Set<members::node_id>;
-        type CreatedAt = St::CreatedAt;
-        type Resource = St::Resource;
+        type NodeId = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type NodeId = St::NodeId;
         type CreatedAt = Set<members::created_at>;
         type Resource = St::Resource;
+        type NodeId = St::NodeId;
     }
     ///State transition - sets the `resource` field to Set
     pub struct SetResource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetResource<St> {}
     impl<St: State> State for SetResource<St> {
-        type NodeId = St::NodeId;
         type CreatedAt = St::CreatedAt;
         type Resource = Set<members::resource>;
+        type NodeId = St::NodeId;
+    }
+    ///State transition - sets the `node_id` field to Set
+    pub struct SetNodeId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNodeId<St> {}
+    impl<St: State> State for SetNodeId<St> {
+        type CreatedAt = St::CreatedAt;
+        type Resource = St::Resource;
+        type NodeId = Set<members::node_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `node_id` field
-        pub struct node_id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `resource` field
         pub struct resource(());
+        ///Marker type for the `node_id` field
+        pub struct node_id(());
     }
 }
 
@@ -287,9 +287,9 @@ where
 impl<S: BosStr, St> SessionBuilder<S, St>
 where
     St: session_state::State,
-    St::NodeId: session_state::IsSet,
     St::CreatedAt: session_state::IsSet,
     St::Resource: session_state::IsSet,
+    St::NodeId: session_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Session<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/edit.rs b/crates/jacquard-api/src/sh_weaver/edit.rs
index f5896d80..67078b8d 100644
--- a/crates/jacquard-api/src/sh_weaver/edit.rs
+++ b/crates/jacquard-api/src/sh_weaver/edit.rs
@@ -768,67 +768,67 @@ pub mod edit_branch_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Length;
         type Head;
-        type Author;
+        type Length;
         type LastUpdated;
+        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Length = Unset;
         type Head = Unset;
-        type Author = Unset;
+        type Length = Unset;
         type LastUpdated = Unset;
-    }
-    ///State transition - sets the `length` field to Set
-    pub struct SetLength<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLength<St> {}
-    impl<St: State> State for SetLength<St> {
-        type Length = Set<members::length>;
-        type Head = St::Head;
-        type Author = St::Author;
-        type LastUpdated = St::LastUpdated;
+        type Author = Unset;
     }
     ///State transition - sets the `head` field to Set
     pub struct SetHead<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHead<St> {}
     impl<St: State> State for SetHead<St> {
-        type Length = St::Length;
         type Head = Set<members::head>;
-        type Author = St::Author;
+        type Length = St::Length;
         type LastUpdated = St::LastUpdated;
+        type Author = St::Author;
     }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Length = St::Length;
+    ///State transition - sets the `length` field to Set
+    pub struct SetLength<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLength<St> {}
+    impl<St: State> State for SetLength<St> {
         type Head = St::Head;
-        type Author = Set<members::author>;
+        type Length = Set<members::length>;
         type LastUpdated = St::LastUpdated;
+        type Author = St::Author;
     }
     ///State transition - sets the `last_updated` field to Set
     pub struct SetLastUpdated<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLastUpdated<St> {}
     impl<St: State> State for SetLastUpdated<St> {
-        type Length = St::Length;
         type Head = St::Head;
-        type Author = St::Author;
+        type Length = St::Length;
         type LastUpdated = Set<members::last_updated>;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type Head = St::Head;
+        type Length = St::Length;
+        type LastUpdated = St::LastUpdated;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `length` field
-        pub struct length(());
         ///Marker type for the `head` field
         pub struct head(());
-        ///Marker type for the `author` field
-        pub struct author(());
+        ///Marker type for the `length` field
+        pub struct length(());
         ///Marker type for the `last_updated` field
         pub struct last_updated(());
+        ///Marker type for the `author` field
+        pub struct author(());
     }
 }
 
@@ -983,10 +983,10 @@ impl<S: BosStr, St: edit_branch_view_state::State> EditBranchViewBuilder<S, St>
 impl<S: BosStr, St> EditBranchViewBuilder<S, St>
 where
     St: edit_branch_view_state::State,
-    St::Length: edit_branch_view_state::IsSet,
     St::Head: edit_branch_view_state::IsSet,
-    St::Author: edit_branch_view_state::IsSet,
+    St::Length: edit_branch_view_state::IsSet,
     St::LastUpdated: edit_branch_view_state::IsSet,
+    St::Author: edit_branch_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EditBranchView<S> {
@@ -1030,84 +1030,84 @@ pub mod edit_history_entry_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Cid;
-        type Type;
         type Uri;
-        type Author;
         type CreatedAt;
+        type Type;
+        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Cid = Unset;
-        type Type = Unset;
         type Uri = Unset;
-        type Author = Unset;
         type CreatedAt = Unset;
+        type Type = Unset;
+        type Author = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
         type Cid = Set<members::cid>;
-        type Type = St::Type;
         type Uri = St::Uri;
-        type Author = St::Author;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Cid = St::Cid;
-        type Type = Set<members::r#type>;
-        type Uri = St::Uri;
+        type Type = St::Type;
         type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
-        type Type = St::Type;
         type Uri = Set<members::uri>;
-        type Author = St::Author;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Cid = St::Cid;
         type Type = St::Type;
-        type Uri = St::Uri;
-        type Author = Set<members::author>;
-        type CreatedAt = St::CreatedAt;
+        type Author = St::Author;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Cid = St::Cid;
+        type Uri = St::Uri;
+        type CreatedAt = Set<members::created_at>;
         type Type = St::Type;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Cid = St::Cid;
         type Uri = St::Uri;
+        type CreatedAt = St::CreatedAt;
+        type Type = Set<members::r#type>;
         type Author = St::Author;
-        type CreatedAt = Set<members::created_at>;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
+        type CreatedAt = St::CreatedAt;
+        type Type = St::Type;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
+        ///Marker type for the `author` field
+        pub struct author(());
     }
 }
 
@@ -1297,10 +1297,10 @@ impl<S: BosStr, St> EditHistoryEntryBuilder<S, St>
 where
     St: edit_history_entry_state::State,
     St::Cid: edit_history_entry_state::IsSet,
-    St::Type: edit_history_entry_state::IsSet,
     St::Uri: edit_history_entry_state::IsSet,
-    St::Author: edit_history_entry_state::IsSet,
     St::CreatedAt: edit_history_entry_state::IsSet,
+    St::Type: edit_history_entry_state::IsSet,
+    St::Author: edit_history_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EditHistoryEntry<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/edit/cursor.rs b/crates/jacquard-api/src/sh_weaver/edit/cursor.rs
index f1464e38..d5538f3b 100644
--- a/crates/jacquard-api/src/sh_weaver/edit/cursor.rs
+++ b/crates/jacquard-api/src/sh_weaver/edit/cursor.rs
@@ -763,37 +763,37 @@ pub mod cursor_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Id;
         type Container;
+        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Id = Unset;
         type Container = Unset;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Id = Set<members::id>;
-        type Container = St::Container;
+        type Id = Unset;
     }
     ///State transition - sets the `container` field to Set
     pub struct SetContainer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContainer<St> {}
     impl<St: State> State for SetContainer<St> {
-        type Id = St::Id;
         type Container = Set<members::container>;
+        type Id = St::Id;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Container = St::Container;
+        type Id = Set<members::id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `container` field
         pub struct container(());
+        ///Marker type for the `id` field
+        pub struct id(());
     }
 }
 
@@ -880,8 +880,8 @@ impl<S: BosStr, St: cursor_state::State> CursorBuilder<S, St> {
 impl<S: BosStr, St> CursorBuilder<S, St>
 where
     St: cursor_state::State,
-    St::Id: cursor_state::IsSet,
     St::Container: cursor_state::IsSet,
+    St::Id: cursor_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Cursor<S> {
@@ -913,51 +913,51 @@ pub mod normal_container_id_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type ContainerType;
         type Counter;
         type Peer;
-        type ContainerType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type ContainerType = Unset;
         type Counter = Unset;
         type Peer = Unset;
-        type ContainerType = Unset;
+    }
+    ///State transition - sets the `container_type` field to Set
+    pub struct SetContainerType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContainerType<St> {}
+    impl<St: State> State for SetContainerType<St> {
+        type ContainerType = Set<members::container_type>;
+        type Counter = St::Counter;
+        type Peer = St::Peer;
     }
     ///State transition - sets the `counter` field to Set
     pub struct SetCounter<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCounter<St> {}
     impl<St: State> State for SetCounter<St> {
+        type ContainerType = St::ContainerType;
         type Counter = Set<members::counter>;
         type Peer = St::Peer;
-        type ContainerType = St::ContainerType;
     }
     ///State transition - sets the `peer` field to Set
     pub struct SetPeer<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPeer<St> {}
     impl<St: State> State for SetPeer<St> {
-        type Counter = St::Counter;
-        type Peer = Set<members::peer>;
         type ContainerType = St::ContainerType;
-    }
-    ///State transition - sets the `container_type` field to Set
-    pub struct SetContainerType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContainerType<St> {}
-    impl<St: State> State for SetContainerType<St> {
         type Counter = St::Counter;
-        type Peer = St::Peer;
-        type ContainerType = Set<members::container_type>;
+        type Peer = Set<members::peer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `container_type` field
+        pub struct container_type(());
         ///Marker type for the `counter` field
         pub struct counter(());
         ///Marker type for the `peer` field
         pub struct peer(());
-        ///Marker type for the `container_type` field
-        pub struct container_type(());
     }
 }
 
@@ -1046,9 +1046,9 @@ where
 impl<S: BosStr, St> NormalContainerIdBuilder<S, St>
 where
     St: normal_container_id_state::State,
+    St::ContainerType: normal_container_id_state::IsSet,
     St::Counter: normal_container_id_state::IsSet,
     St::Peer: normal_container_id_state::IsSet,
-    St::ContainerType: normal_container_id_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NormalContainerId<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/edit/list_drafts.rs b/crates/jacquard-api/src/sh_weaver/edit/list_drafts.rs
index cd9c6868..ea677230 100644
--- a/crates/jacquard-api/src/sh_weaver/edit/list_drafts.rs
+++ b/crates/jacquard-api/src/sh_weaver/edit/list_drafts.rs
@@ -120,51 +120,51 @@ pub mod draft_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type Cid;
         type CreatedAt;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type Cid = Unset;
         type CreatedAt = Unset;
-        type Uri = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
         type Cid = Set<members::cid>;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Cid = St::Cid;
-        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
-        type CreatedAt = St::CreatedAt;
-        type Uri = Set<members::uri>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -299,9 +299,9 @@ where
 impl<S: BosStr, St> DraftViewBuilder<S, St>
 where
     St: draft_view_state::State,
+    St::Uri: draft_view_state::IsSet,
     St::Cid: draft_view_state::IsSet,
     St::CreatedAt: draft_view_state::IsSet,
-    St::Uri: draft_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DraftView<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/edit/root.rs b/crates/jacquard-api/src/sh_weaver/edit/root.rs
index b924af50..c1213d84 100644
--- a/crates/jacquard-api/src/sh_weaver/edit/root.rs
+++ b/crates/jacquard-api/src/sh_weaver/edit/root.rs
@@ -154,37 +154,37 @@ pub mod root_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Snapshot;
         type Doc;
+        type Snapshot;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Snapshot = Unset;
         type Doc = Unset;
-    }
-    ///State transition - sets the `snapshot` field to Set
-    pub struct SetSnapshot<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSnapshot<St> {}
-    impl<St: State> State for SetSnapshot<St> {
-        type Snapshot = Set<members::snapshot>;
-        type Doc = St::Doc;
+        type Snapshot = Unset;
     }
     ///State transition - sets the `doc` field to Set
     pub struct SetDoc<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDoc<St> {}
     impl<St: State> State for SetDoc<St> {
-        type Snapshot = St::Snapshot;
         type Doc = Set<members::doc>;
+        type Snapshot = St::Snapshot;
+    }
+    ///State transition - sets the `snapshot` field to Set
+    pub struct SetSnapshot<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSnapshot<St> {}
+    impl<St: State> State for SetSnapshot<St> {
+        type Doc = St::Doc;
+        type Snapshot = Set<members::snapshot>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `snapshot` field
-        pub struct snapshot(());
         ///Marker type for the `doc` field
         pub struct doc(());
+        ///Marker type for the `snapshot` field
+        pub struct snapshot(());
     }
 }
 
@@ -254,8 +254,8 @@ where
 impl<S: BosStr, St> RootBuilder<S, St>
 where
     St: root_state::State,
-    St::Snapshot: root_state::IsSet,
     St::Doc: root_state::IsSet,
+    St::Snapshot: root_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Root<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed.rs b/crates/jacquard-api/src/sh_weaver/embed.rs
index 04935b76..bb2179bc 100644
--- a/crates/jacquard-api/src/sh_weaver/embed.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed.rs
@@ -304,37 +304,37 @@ pub mod pixel_size_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -404,8 +404,8 @@ where
 impl<S: BosStr, St> PixelSizeBuilder<S, St>
 where
     St: pixel_size_state::State,
-    St::Width: pixel_size_state::IsSet,
     St::Height: pixel_size_state::IsSet,
+    St::Width: pixel_size_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PixelSize<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed/external.rs b/crates/jacquard-api/src/sh_weaver/embed/external.rs
index 62b4b792..90c6e510 100644
--- a/crates/jacquard-api/src/sh_weaver/embed/external.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed/external.rs
@@ -200,51 +200,51 @@ pub mod external_embed_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Description;
-        type Title;
         type Uri;
+        type Title;
+        type Description;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Description = Unset;
-        type Title = Unset;
         type Uri = Unset;
+        type Title = Unset;
+        type Description = Unset;
     }
-    ///State transition - sets the `description` field to Set
-    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDescription<St> {}
-    impl<St: State> State for SetDescription<St> {
-        type Description = Set<members::description>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Title = St::Title;
-        type Uri = St::Uri;
+        type Description = St::Description;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Description = St::Description;
-        type Title = Set<members::title>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Title = Set<members::title>;
         type Description = St::Description;
+    }
+    ///State transition - sets the `description` field to Set
+    pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDescription<St> {}
+    impl<St: State> State for SetDescription<St> {
+        type Uri = St::Uri;
         type Title = St::Title;
-        type Uri = Set<members::uri>;
+        type Description = Set<members::description>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `description` field
-        pub struct description(());
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `description` field
+        pub struct description(());
     }
 }
 
@@ -346,9 +346,9 @@ where
 impl<S: BosStr, St> ExternalEmbedBuilder<S, St>
 where
     St: external_embed_state::State,
-    St::Description: external_embed_state::IsSet,
-    St::Title: external_embed_state::IsSet,
     St::Uri: external_embed_state::IsSet,
+    St::Title: external_embed_state::IsSet,
+    St::Description: external_embed_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ExternalEmbed<S> {
@@ -716,51 +716,51 @@ pub mod view_external_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
-        type Description;
         type Uri;
+        type Description;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
-        type Description = Unset;
         type Uri = Unset;
+        type Description = Unset;
+        type Title = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Description = St::Description;
-        type Uri = St::Uri;
+        type Title = St::Title;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type Title = St::Title;
-        type Description = Set<members::description>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Description = Set<members::description>;
         type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Uri = St::Uri;
         type Description = St::Description;
-        type Uri = Set<members::uri>;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `description` field
+        pub struct description(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -862,9 +862,9 @@ where
 impl<S: BosStr, St> ViewExternalBuilder<S, St>
 where
     St: view_external_state::State,
-    St::Title: view_external_state::IsSet,
-    St::Description: view_external_state::IsSet,
     St::Uri: view_external_state::IsSet,
+    St::Description: view_external_state::IsSet,
+    St::Title: view_external_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewExternal<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed/images.rs b/crates/jacquard-api/src/sh_weaver/embed/images.rs
index e13bbc8c..cfb2e66f 100644
--- a/crates/jacquard-api/src/sh_weaver/embed/images.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed/images.rs
@@ -836,51 +836,51 @@ pub mod view_image_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Alt;
-        type Thumb;
         type Fullsize;
+        type Thumb;
+        type Alt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Alt = Unset;
-        type Thumb = Unset;
         type Fullsize = Unset;
+        type Thumb = Unset;
+        type Alt = Unset;
     }
-    ///State transition - sets the `alt` field to Set
-    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAlt<St> {}
-    impl<St: State> State for SetAlt<St> {
-        type Alt = Set<members::alt>;
+    ///State transition - sets the `fullsize` field to Set
+    pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFullsize<St> {}
+    impl<St: State> State for SetFullsize<St> {
+        type Fullsize = Set<members::fullsize>;
         type Thumb = St::Thumb;
-        type Fullsize = St::Fullsize;
+        type Alt = St::Alt;
     }
     ///State transition - sets the `thumb` field to Set
     pub struct SetThumb<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetThumb<St> {}
     impl<St: State> State for SetThumb<St> {
-        type Alt = St::Alt;
-        type Thumb = Set<members::thumb>;
         type Fullsize = St::Fullsize;
-    }
-    ///State transition - sets the `fullsize` field to Set
-    pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFullsize<St> {}
-    impl<St: State> State for SetFullsize<St> {
+        type Thumb = Set<members::thumb>;
         type Alt = St::Alt;
+    }
+    ///State transition - sets the `alt` field to Set
+    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAlt<St> {}
+    impl<St: State> State for SetAlt<St> {
+        type Fullsize = St::Fullsize;
         type Thumb = St::Thumb;
-        type Fullsize = Set<members::fullsize>;
+        type Alt = Set<members::alt>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `alt` field
-        pub struct alt(());
-        ///Marker type for the `thumb` field
-        pub struct thumb(());
         ///Marker type for the `fullsize` field
         pub struct fullsize(());
+        ///Marker type for the `thumb` field
+        pub struct thumb(());
+        ///Marker type for the `alt` field
+        pub struct alt(());
     }
 }
 
@@ -1004,9 +1004,9 @@ where
 impl<S: BosStr, St> ViewImageBuilder<S, St>
 where
     St: view_image_state::State,
-    St::Alt: view_image_state::IsSet,
-    St::Thumb: view_image_state::IsSet,
     St::Fullsize: view_image_state::IsSet,
+    St::Thumb: view_image_state::IsSet,
+    St::Alt: view_image_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewImage<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs b/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs
index 141ff7ba..4cb79ff5 100644
--- a/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed/record_with_media.rs
@@ -118,37 +118,37 @@ pub mod record_with_media_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Records;
         type Media;
+        type Records;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Records = Unset;
         type Media = Unset;
-    }
-    ///State transition - sets the `records` field to Set
-    pub struct SetRecords<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecords<St> {}
-    impl<St: State> State for SetRecords<St> {
-        type Records = Set<members::records>;
-        type Media = St::Media;
+        type Records = Unset;
     }
     ///State transition - sets the `media` field to Set
     pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMedia<St> {}
     impl<St: State> State for SetMedia<St> {
-        type Records = St::Records;
         type Media = Set<members::media>;
+        type Records = St::Records;
+    }
+    ///State transition - sets the `records` field to Set
+    pub struct SetRecords<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecords<St> {}
+    impl<St: State> State for SetRecords<St> {
+        type Media = St::Media;
+        type Records = Set<members::records>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `records` field
-        pub struct records(());
         ///Marker type for the `media` field
         pub struct media(());
+        ///Marker type for the `records` field
+        pub struct records(());
     }
 }
 
@@ -218,8 +218,8 @@ where
 impl<S: BosStr, St> RecordWithMediaBuilder<S, St>
 where
     St: record_with_media_state::State,
-    St::Records: record_with_media_state::IsSet,
     St::Media: record_with_media_state::IsSet,
+    St::Records: record_with_media_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RecordWithMedia<S> {
@@ -334,37 +334,37 @@ pub mod view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Media;
         type Record;
+        type Media;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Media = Unset;
         type Record = Unset;
-    }
-    ///State transition - sets the `media` field to Set
-    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMedia<St> {}
-    impl<St: State> State for SetMedia<St> {
-        type Media = Set<members::media>;
-        type Record = St::Record;
+        type Media = Unset;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type Media = St::Media;
         type Record = Set<members::record>;
+        type Media = St::Media;
+    }
+    ///State transition - sets the `media` field to Set
+    pub struct SetMedia<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMedia<St> {}
+    impl<St: State> State for SetMedia<St> {
+        type Record = St::Record;
+        type Media = Set<members::media>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `media` field
-        pub struct media(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `media` field
+        pub struct media(());
     }
 }
 
@@ -428,8 +428,8 @@ impl<S: BosStr, St: view_state::State> ViewBuilder<S, St> {
 impl<S: BosStr, St> ViewBuilder<S, St>
 where
     St: view_state::State,
-    St::Media: view_state::IsSet,
     St::Record: view_state::IsSet,
+    St::Media: view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> View<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed/records.rs b/crates/jacquard-api/src/sh_weaver/embed/records.rs
index b62231d5..2e477d58 100644
--- a/crates/jacquard-api/src/sh_weaver/embed/records.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed/records.rs
@@ -1071,51 +1071,51 @@ pub mod view_blocked_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Author;
         type Uri;
         type Blocked;
+        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Author = Unset;
         type Uri = Unset;
         type Blocked = Unset;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Author = Set<members::author>;
-        type Uri = St::Uri;
-        type Blocked = St::Blocked;
+        type Author = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Author = St::Author;
         type Uri = Set<members::uri>;
         type Blocked = St::Blocked;
+        type Author = St::Author;
     }
     ///State transition - sets the `blocked` field to Set
     pub struct SetBlocked<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlocked<St> {}
     impl<St: State> State for SetBlocked<St> {
-        type Author = St::Author;
         type Uri = St::Uri;
         type Blocked = Set<members::blocked>;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type Uri = St::Uri;
+        type Blocked = St::Blocked;
+        type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `blocked` field
         pub struct blocked(());
+        ///Marker type for the `author` field
+        pub struct author(());
     }
 }
 
@@ -1204,9 +1204,9 @@ where
 impl<S: BosStr, St> ViewBlockedBuilder<S, St>
 where
     St: view_blocked_state::State,
-    St::Author: view_blocked_state::IsSet,
     St::Uri: view_blocked_state::IsSet,
     St::Blocked: view_blocked_state::IsSet,
+    St::Author: view_blocked_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewBlocked<S> {
@@ -1375,37 +1375,37 @@ pub mod view_not_found_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type NotFound;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type NotFound = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type NotFound = St::NotFound;
+        type Uri = Unset;
     }
     ///State transition - sets the `not_found` field to Set
     pub struct SetNotFound<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotFound<St> {}
     impl<St: State> State for SetNotFound<St> {
-        type Uri = St::Uri;
         type NotFound = Set<members::not_found>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type NotFound = St::NotFound;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `not_found` field
         pub struct not_found(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -1475,8 +1475,8 @@ where
 impl<S: BosStr, St> ViewNotFoundBuilder<S, St>
 where
     St: view_not_found_state::State,
-    St::Uri: view_not_found_state::IsSet,
     St::NotFound: view_not_found_state::IsSet,
+    St::Uri: view_not_found_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewNotFound<S> {
@@ -1509,85 +1509,85 @@ pub mod view_record_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
-        type Author;
-        type Value;
         type IndexedAt;
+        type Author;
         type Uri;
+        type Cid;
+        type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
-        type Author = Unset;
-        type Value = Unset;
         type IndexedAt = Unset;
+        type Author = Unset;
         type Uri = Unset;
+        type Cid = Unset;
+        type Value = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type IndexedAt = Set<members::indexed_at>;
         type Author = St::Author;
-        type Value = St::Value;
-        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Value = St::Value;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Cid = St::Cid;
-        type Author = Set<members::author>;
-        type Value = St::Value;
-        type IndexedAt = St::IndexedAt;
-        type Uri = St::Uri;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
-        type Cid = St::Cid;
-        type Author = St::Author;
-        type Value = Set<members::value>;
         type IndexedAt = St::IndexedAt;
+        type Author = Set<members::author>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
         type Cid = St::Cid;
-        type Author = St::Author;
         type Value = St::Value;
-        type IndexedAt = Set<members::indexed_at>;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type IndexedAt = St::IndexedAt;
         type Author = St::Author;
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Value = St::Value;
+    }
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
         type IndexedAt = St::IndexedAt;
-        type Uri = Set<members::uri>;
+        type Author = St::Author;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `author` field
-        pub struct author(());
-        ///Marker type for the `value` field
-        pub struct value(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
+        ///Marker type for the `author` field
+        pub struct author(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `value` field
+        pub struct value(());
     }
 }
 
@@ -1810,11 +1810,11 @@ where
 impl<S: BosStr, St> ViewRecordBuilder<S, St>
 where
     St: view_record_state::State,
-    St::Cid: view_record_state::IsSet,
-    St::Author: view_record_state::IsSet,
-    St::Value: view_record_state::IsSet,
     St::IndexedAt: view_record_state::IsSet,
+    St::Author: view_record_state::IsSet,
     St::Uri: view_record_state::IsSet,
+    St::Cid: view_record_state::IsSet,
+    St::Value: view_record_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ViewRecord<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/embed/video.rs b/crates/jacquard-api/src/sh_weaver/embed/video.rs
index c9ee9a19..e6548c38 100644
--- a/crates/jacquard-api/src/sh_weaver/embed/video.rs
+++ b/crates/jacquard-api/src/sh_weaver/embed/video.rs
@@ -335,37 +335,37 @@ pub mod caption_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Lang;
         type File;
+        type Lang;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Lang = Unset;
         type File = Unset;
-    }
-    ///State transition - sets the `lang` field to Set
-    pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLang<St> {}
-    impl<St: State> State for SetLang<St> {
-        type Lang = Set<members::lang>;
-        type File = St::File;
+        type Lang = Unset;
     }
     ///State transition - sets the `file` field to Set
     pub struct SetFile<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFile<St> {}
     impl<St: State> State for SetFile<St> {
-        type Lang = St::Lang;
         type File = Set<members::file>;
+        type Lang = St::Lang;
+    }
+    ///State transition - sets the `lang` field to Set
+    pub struct SetLang<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLang<St> {}
+    impl<St: State> State for SetLang<St> {
+        type File = St::File;
+        type Lang = Set<members::lang>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `lang` field
-        pub struct lang(());
         ///Marker type for the `file` field
         pub struct file(());
+        ///Marker type for the `lang` field
+        pub struct lang(());
     }
 }
 
@@ -435,8 +435,8 @@ where
 impl<S: BosStr, St> CaptionBuilder<S, St>
 where
     St: caption_state::State,
-    St::Lang: caption_state::IsSet,
     St::File: caption_state::IsSet,
+    St::Lang: caption_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Caption<S> {
@@ -911,37 +911,37 @@ pub mod view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Playlist;
         type Cid;
+        type Playlist;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Playlist = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `playlist` field to Set
-    pub struct SetPlaylist<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPlaylist<St> {}
-    impl<St: State> State for SetPlaylist<St> {
-        type Playlist = Set<members::playlist>;
-        type Cid = St::Cid;
+        type Playlist = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Playlist = St::Playlist;
         type Cid = Set<members::cid>;
+        type Playlist = St::Playlist;
+    }
+    ///State transition - sets the `playlist` field to Set
+    pub struct SetPlaylist<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPlaylist<St> {}
+    impl<St: State> State for SetPlaylist<St> {
+        type Cid = St::Cid;
+        type Playlist = Set<members::playlist>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `playlist` field
-        pub struct playlist(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `playlist` field
+        pub struct playlist(());
     }
 }
 
@@ -1070,8 +1070,8 @@ impl<S: BosStr, St: view_state::State> ViewBuilder<S, St> {
 impl<S: BosStr, St> ViewBuilder<S, St>
 where
     St: view_state::State,
-    St::Playlist: view_state::IsSet,
     St::Cid: view_state::IsSet,
+    St::Playlist: view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> View<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph.rs b/crates/jacquard-api/src/sh_weaver/graph.rs
index 4c1767a3..a5cc6113 100644
--- a/crates/jacquard-api/src/sh_weaver/graph.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph.rs
@@ -377,37 +377,37 @@ pub mod community_tag_count_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Tag;
         type Count;
+        type Tag;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Tag = Unset;
         type Count = Unset;
-    }
-    ///State transition - sets the `tag` field to Set
-    pub struct SetTag<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTag<St> {}
-    impl<St: State> State for SetTag<St> {
-        type Tag = Set<members::tag>;
-        type Count = St::Count;
+        type Tag = Unset;
     }
     ///State transition - sets the `count` field to Set
     pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCount<St> {}
     impl<St: State> State for SetCount<St> {
-        type Tag = St::Tag;
         type Count = Set<members::count>;
+        type Tag = St::Tag;
+    }
+    ///State transition - sets the `tag` field to Set
+    pub struct SetTag<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTag<St> {}
+    impl<St: State> State for SetTag<St> {
+        type Count = St::Count;
+        type Tag = Set<members::tag>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `tag` field
-        pub struct tag(());
         ///Marker type for the `count` field
         pub struct count(());
+        ///Marker type for the `tag` field
+        pub struct tag(());
     }
 }
 
@@ -477,8 +477,8 @@ where
 impl<S: BosStr, St> CommunityTagCountBuilder<S, St>
 where
     St: community_tag_count_state::State,
-    St::Tag: community_tag_count_state::IsSet,
     St::Count: community_tag_count_state::IsSet,
+    St::Tag: community_tag_count_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CommunityTagCount<S> {
@@ -871,37 +871,37 @@ pub mod list_item_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type Uri;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type Uri = St::Uri;
+        type Subject = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Subject = St::Subject;
         type Uri = Set<members::uri>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Uri = St::Uri;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -984,8 +984,8 @@ where
 impl<S: BosStr, St> ListItemViewBuilder<S, St>
 where
     St: list_item_view_state::State,
-    St::Subject: list_item_view_state::IsSet,
     St::Uri: list_item_view_state::IsSet,
+    St::Subject: list_item_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ListItemView<S> {
@@ -1020,125 +1020,125 @@ pub mod list_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
+        type Name;
+        type Cid;
+        type Purpose;
         type ItemCount;
+        type Uri;
         type IndexedAt;
-        type Purpose;
-        type Cid;
-        type Name;
         type Creator;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
+        type Name = Unset;
+        type Cid = Unset;
+        type Purpose = Unset;
         type ItemCount = Unset;
+        type Uri = Unset;
         type IndexedAt = Unset;
-        type Purpose = Unset;
-        type Cid = Unset;
-        type Name = Unset;
         type Creator = Unset;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type ItemCount = St::ItemCount;
-        type IndexedAt = St::IndexedAt;
-        type Purpose = St::Purpose;
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Name = Set<members::name>;
         type Cid = St::Cid;
-        type Name = St::Name;
-        type Creator = St::Creator;
-    }
-    ///State transition - sets the `item_count` field to Set
-    pub struct SetItemCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetItemCount<St> {}
-    impl<St: State> State for SetItemCount<St> {
+        type Purpose = St::Purpose;
+        type ItemCount = St::ItemCount;
         type Uri = St::Uri;
-        type ItemCount = Set<members::item_count>;
         type IndexedAt = St::IndexedAt;
-        type Purpose = St::Purpose;
-        type Cid = St::Cid;
-        type Name = St::Name;
         type Creator = St::Creator;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Uri = St::Uri;
-        type ItemCount = St::ItemCount;
-        type IndexedAt = Set<members::indexed_at>;
-        type Purpose = St::Purpose;
-        type Cid = St::Cid;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Name = St::Name;
+        type Cid = Set<members::cid>;
+        type Purpose = St::Purpose;
+        type ItemCount = St::ItemCount;
+        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
         type Creator = St::Creator;
     }
     ///State transition - sets the `purpose` field to Set
     pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPurpose<St> {}
     impl<St: State> State for SetPurpose<St> {
-        type Uri = St::Uri;
+        type Name = St::Name;
+        type Cid = St::Cid;
+        type Purpose = Set<members::purpose>;
         type ItemCount = St::ItemCount;
+        type Uri = St::Uri;
         type IndexedAt = St::IndexedAt;
-        type Purpose = Set<members::purpose>;
-        type Cid = St::Cid;
-        type Name = St::Name;
         type Creator = St::Creator;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+    ///State transition - sets the `item_count` field to Set
+    pub struct SetItemCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetItemCount<St> {}
+    impl<St: State> State for SetItemCount<St> {
+        type Name = St::Name;
+        type Cid = St::Cid;
+        type Purpose = St::Purpose;
+        type ItemCount = Set<members::item_count>;
         type Uri = St::Uri;
-        type ItemCount = St::ItemCount;
         type IndexedAt = St::IndexedAt;
-        type Purpose = St::Purpose;
-        type Cid = Set<members::cid>;
-        type Name = St::Name;
         type Creator = St::Creator;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Uri = St::Uri;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Name = St::Name;
+        type Cid = St::Cid;
+        type Purpose = St::Purpose;
         type ItemCount = St::ItemCount;
+        type Uri = Set<members::uri>;
         type IndexedAt = St::IndexedAt;
-        type Purpose = St::Purpose;
+        type Creator = St::Creator;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Name = St::Name;
         type Cid = St::Cid;
-        type Name = Set<members::name>;
+        type Purpose = St::Purpose;
+        type ItemCount = St::ItemCount;
+        type Uri = St::Uri;
+        type IndexedAt = Set<members::indexed_at>;
         type Creator = St::Creator;
     }
     ///State transition - sets the `creator` field to Set
     pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreator<St> {}
     impl<St: State> State for SetCreator<St> {
-        type Uri = St::Uri;
+        type Name = St::Name;
+        type Cid = St::Cid;
+        type Purpose = St::Purpose;
         type ItemCount = St::ItemCount;
+        type Uri = St::Uri;
         type IndexedAt = St::IndexedAt;
-        type Purpose = St::Purpose;
-        type Cid = St::Cid;
-        type Name = St::Name;
         type Creator = Set<members::creator>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `purpose` field
+        pub struct purpose(());
         ///Marker type for the `item_count` field
         pub struct item_count(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `purpose` field
-        pub struct purpose(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `creator` field
         pub struct creator(());
     }
@@ -1355,12 +1355,12 @@ impl<S: BosStr, St: list_view_state::State> ListViewBuilder<S, St> {
 impl<S: BosStr, St> ListViewBuilder<S, St>
 where
     St: list_view_state::State,
-    St::Uri: list_view_state::IsSet,
+    St::Name: list_view_state::IsSet,
+    St::Cid: list_view_state::IsSet,
+    St::Purpose: list_view_state::IsSet,
     St::ItemCount: list_view_state::IsSet,
+    St::Uri: list_view_state::IsSet,
     St::IndexedAt: list_view_state::IsSet,
-    St::Purpose: list_view_state::IsSet,
-    St::Cid: list_view_state::IsSet,
-    St::Name: list_view_state::IsSet,
     St::Creator: list_view_state::IsSet,
 {
     /// Build the final struct.
@@ -1597,67 +1597,67 @@ pub mod tag_application_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type AppliedBy;
         type Tag;
         type CreatedAt;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type AppliedBy = Unset;
         type Tag = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type AppliedBy = St::AppliedBy;
-        type Tag = St::Tag;
-        type CreatedAt = St::CreatedAt;
+        type Uri = Unset;
     }
     ///State transition - sets the `applied_by` field to Set
     pub struct SetAppliedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAppliedBy<St> {}
     impl<St: State> State for SetAppliedBy<St> {
-        type Uri = St::Uri;
         type AppliedBy = Set<members::applied_by>;
         type Tag = St::Tag;
         type CreatedAt = St::CreatedAt;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `tag` field to Set
     pub struct SetTag<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTag<St> {}
     impl<St: State> State for SetTag<St> {
-        type Uri = St::Uri;
         type AppliedBy = St::AppliedBy;
         type Tag = Set<members::tag>;
         type CreatedAt = St::CreatedAt;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Uri = St::Uri;
         type AppliedBy = St::AppliedBy;
         type Tag = St::Tag;
         type CreatedAt = Set<members::created_at>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type AppliedBy = St::AppliedBy;
+        type Tag = St::Tag;
+        type CreatedAt = St::CreatedAt;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `applied_by` field
         pub struct applied_by(());
         ///Marker type for the `tag` field
         pub struct tag(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -1770,10 +1770,10 @@ where
 impl<S: BosStr, St> TagApplicationViewBuilder<S, St>
 where
     St: tag_application_view_state::State,
-    St::Uri: tag_application_view_state::IsSet,
     St::AppliedBy: tag_application_view_state::IsSet,
     St::Tag: tag_application_view_state::IsSet,
     St::CreatedAt: tag_application_view_state::IsSet,
+    St::Uri: tag_application_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TagApplicationView<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/follow_accept.rs b/crates/jacquard-api/src/sh_weaver/graph/follow_accept.rs
index 183b6438..e56da319 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/follow_accept.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/follow_accept.rs
@@ -114,37 +114,37 @@ pub mod follow_accept_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Follow;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Follow = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Follow = St::Follow;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `follow` field to Set
     pub struct SetFollow<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFollow<St> {}
     impl<St: State> State for SetFollow<St> {
-        type CreatedAt = St::CreatedAt;
         type Follow = Set<members::follow>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Follow = St::Follow;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `follow` field
         pub struct follow(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> FollowAcceptBuilder<S, St>
 where
     St: follow_accept_state::State,
-    St::CreatedAt: follow_accept_state::IsSet,
     St::Follow: follow_accept_state::IsSet,
+    St::CreatedAt: follow_accept_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FollowAccept<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/like.rs b/crates/jacquard-api/src/sh_weaver/graph/like.rs
index 0764d46a..890ea4c3 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/like.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/like.rs
@@ -114,37 +114,37 @@ pub mod like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
         type CreatedAt = Set<members::created_at>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> LikeBuilder<S, St>
 where
     St: like_state::State,
-    St::Subject: like_state::IsSet,
     St::CreatedAt: like_state::IsSet,
+    St::Subject: like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Like<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/list.rs b/crates/jacquard-api/src/sh_weaver/graph/list.rs
index c3e1967e..b15d88b5 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/list.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/list.rs
@@ -281,51 +281,51 @@ pub mod list_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type CreatedAt;
         type Purpose;
+        type CreatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type CreatedAt = Unset;
         type Purpose = Unset;
+        type CreatedAt = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `purpose` field to Set
+    pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPurpose<St> {}
+    impl<St: State> State for SetPurpose<St> {
+        type Purpose = Set<members::purpose>;
         type CreatedAt = St::CreatedAt;
-        type Purpose = St::Purpose;
+        type Name = St::Name;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
         type Purpose = St::Purpose;
-    }
-    ///State transition - sets the `purpose` field to Set
-    pub struct SetPurpose<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPurpose<St> {}
-    impl<St: State> State for SetPurpose<St> {
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Purpose = St::Purpose;
         type CreatedAt = St::CreatedAt;
-        type Purpose = Set<members::purpose>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `purpose` field
         pub struct purpose(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -446,9 +446,9 @@ where
 impl<S: BosStr, St> ListBuilder<S, St>
 where
     St: list_state::State,
-    St::Name: list_state::IsSet,
-    St::CreatedAt: list_state::IsSet,
     St::Purpose: list_state::IsSet,
+    St::CreatedAt: list_state::IsSet,
+    St::Name: list_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> List<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/listitem.rs b/crates/jacquard-api/src/sh_weaver/graph/listitem.rs
index c8d70649..6371e22d 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/listitem.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/listitem.rs
@@ -116,51 +116,51 @@ pub mod listitem_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type List;
         type Subject;
         type CreatedAt;
-        type List;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type List = Unset;
         type Subject = Unset;
         type CreatedAt = Unset;
-        type List = Unset;
+    }
+    ///State transition - sets the `list` field to Set
+    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetList<St> {}
+    impl<St: State> State for SetList<St> {
+        type List = Set<members::list>;
+        type Subject = St::Subject;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
+        type List = St::List;
         type Subject = Set<members::subject>;
         type CreatedAt = St::CreatedAt;
-        type List = St::List;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
         type List = St::List;
-    }
-    ///State transition - sets the `list` field to Set
-    pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetList<St> {}
-    impl<St: State> State for SetList<St> {
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
-        type List = Set<members::list>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `list` field
+        pub struct list(());
         ///Marker type for the `subject` field
         pub struct subject(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `list` field
-        pub struct list(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> ListitemBuilder<S, St>
 where
     St: listitem_state::State,
+    St::List: listitem_state::IsSet,
     St::Subject: listitem_state::IsSet,
     St::CreatedAt: listitem_state::IsSet,
-    St::List: listitem_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Listitem<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/subscribe.rs b/crates/jacquard-api/src/sh_weaver/graph/subscribe.rs
index 7a2c5204..e525500b 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/subscribe.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/subscribe.rs
@@ -113,37 +113,37 @@ pub mod subscribe_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Notebook;
         type CreatedAt;
+        type Notebook;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Notebook = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `notebook` field to Set
-    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotebook<St> {}
-    impl<St: State> State for SetNotebook<St> {
-        type Notebook = Set<members::notebook>;
-        type CreatedAt = St::CreatedAt;
+        type Notebook = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Notebook = St::Notebook;
         type CreatedAt = Set<members::created_at>;
+        type Notebook = St::Notebook;
+    }
+    ///State transition - sets the `notebook` field to Set
+    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotebook<St> {}
+    impl<St: State> State for SetNotebook<St> {
+        type CreatedAt = St::CreatedAt;
+        type Notebook = Set<members::notebook>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `notebook` field
-        pub struct notebook(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `notebook` field
+        pub struct notebook(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> SubscribeBuilder<S, St>
 where
     St: subscribe_state::State,
-    St::Notebook: subscribe_state::IsSet,
     St::CreatedAt: subscribe_state::IsSet,
+    St::Notebook: subscribe_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Subscribe<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/graph/subscribe_accept.rs b/crates/jacquard-api/src/sh_weaver/graph/subscribe_accept.rs
index 68a27a03..0cdce97d 100644
--- a/crates/jacquard-api/src/sh_weaver/graph/subscribe_accept.rs
+++ b/crates/jacquard-api/src/sh_weaver/graph/subscribe_accept.rs
@@ -114,37 +114,37 @@ pub mod subscribe_accept_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subscribe;
         type CreatedAt;
+        type Subscribe;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subscribe = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `subscribe` field to Set
-    pub struct SetSubscribe<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubscribe<St> {}
-    impl<St: State> State for SetSubscribe<St> {
-        type Subscribe = Set<members::subscribe>;
-        type CreatedAt = St::CreatedAt;
+        type Subscribe = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Subscribe = St::Subscribe;
         type CreatedAt = Set<members::created_at>;
+        type Subscribe = St::Subscribe;
+    }
+    ///State transition - sets the `subscribe` field to Set
+    pub struct SetSubscribe<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubscribe<St> {}
+    impl<St: State> State for SetSubscribe<St> {
+        type CreatedAt = St::CreatedAt;
+        type Subscribe = Set<members::subscribe>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subscribe` field
-        pub struct subscribe(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `subscribe` field
+        pub struct subscribe(());
     }
 }
 
@@ -214,8 +214,8 @@ where
 impl<S: BosStr, St> SubscribeAcceptBuilder<S, St>
 where
     St: subscribe_accept_state::State,
-    St::Subscribe: subscribe_accept_state::IsSet,
     St::CreatedAt: subscribe_accept_state::IsSet,
+    St::Subscribe: subscribe_accept_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubscribeAccept<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook.rs b/crates/jacquard-api/src/sh_weaver/notebook.rs
index 79196ab1..07a6d6fd 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook.rs
@@ -2493,37 +2493,37 @@ pub mod book_entry_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Index;
         type Entry;
+        type Index;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Index = Unset;
         type Entry = Unset;
-    }
-    ///State transition - sets the `index` field to Set
-    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndex<St> {}
-    impl<St: State> State for SetIndex<St> {
-        type Index = Set<members::index>;
-        type Entry = St::Entry;
+        type Index = Unset;
     }
     ///State transition - sets the `entry` field to Set
     pub struct SetEntry<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEntry<St> {}
     impl<St: State> State for SetEntry<St> {
-        type Index = St::Index;
         type Entry = Set<members::entry>;
+        type Index = St::Index;
+    }
+    ///State transition - sets the `index` field to Set
+    pub struct SetIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndex<St> {}
+    impl<St: State> State for SetIndex<St> {
+        type Entry = St::Entry;
+        type Index = Set<members::index>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `index` field
-        pub struct index(());
         ///Marker type for the `entry` field
         pub struct entry(());
+        ///Marker type for the `index` field
+        pub struct index(());
     }
 }
 
@@ -2624,8 +2624,8 @@ impl<S: BosStr, St: book_entry_view_state::State> BookEntryViewBuilder<S, St> {
 impl<S: BosStr, St> BookEntryViewBuilder<S, St>
 where
     St: book_entry_view_state::State,
-    St::Index: book_entry_view_state::IsSet,
     St::Entry: book_entry_view_state::IsSet,
+    St::Index: book_entry_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BookEntryView<S> {
@@ -2831,105 +2831,105 @@ pub mod chapter_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IndexedAt;
-        type Cid;
         type Uri;
-        type Authors;
+        type Cid;
         type Notebook;
         type Record;
+        type Authors;
+        type IndexedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IndexedAt = Unset;
-        type Cid = Unset;
         type Uri = Unset;
-        type Authors = Unset;
+        type Cid = Unset;
         type Notebook = Unset;
         type Record = Unset;
+        type Authors = Unset;
+        type IndexedAt = Unset;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
-        type Uri = St::Uri;
-        type Authors = St::Authors;
         type Notebook = St::Notebook;
         type Record = St::Record;
+        type Authors = St::Authors;
+        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = Set<members::cid>;
         type Uri = St::Uri;
-        type Authors = St::Authors;
+        type Cid = Set<members::cid>;
         type Notebook = St::Notebook;
         type Record = St::Record;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Uri = Set<members::uri>;
         type Authors = St::Authors;
-        type Notebook = St::Notebook;
-        type Record = St::Record;
-    }
-    ///State transition - sets the `authors` field to Set
-    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthors<St> {}
-    impl<St: State> State for SetAuthors<St> {
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Uri = St::Uri;
-        type Authors = Set<members::authors>;
-        type Notebook = St::Notebook;
-        type Record = St::Record;
     }
     ///State transition - sets the `notebook` field to Set
     pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotebook<St> {}
     impl<St: State> State for SetNotebook<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Uri = St::Uri;
-        type Authors = St::Authors;
+        type Cid = St::Cid;
         type Notebook = Set<members::notebook>;
         type Record = St::Record;
+        type Authors = St::Authors;
+        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Notebook = St::Notebook;
+        type Record = Set<members::record>;
+        type Authors = St::Authors;
         type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `authors` field to Set
+    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthors<St> {}
+    impl<St: State> State for SetAuthors<St> {
+        type Uri = St::Uri;
         type Cid = St::Cid;
+        type Notebook = St::Notebook;
+        type Record = St::Record;
+        type Authors = Set<members::authors>;
+        type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
         type Uri = St::Uri;
-        type Authors = St::Authors;
+        type Cid = St::Cid;
         type Notebook = St::Notebook;
-        type Record = Set<members::record>;
+        type Record = St::Record;
+        type Authors = St::Authors;
+        type IndexedAt = Set<members::indexed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `authors` field
-        pub struct authors(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `notebook` field
         pub struct notebook(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
     }
 }
 
@@ -3124,12 +3124,12 @@ where
 impl<S: BosStr, St> ChapterViewBuilder<S, St>
 where
     St: chapter_view_state::State,
-    St::IndexedAt: chapter_view_state::IsSet,
-    St::Cid: chapter_view_state::IsSet,
     St::Uri: chapter_view_state::IsSet,
-    St::Authors: chapter_view_state::IsSet,
+    St::Cid: chapter_view_state::IsSet,
     St::Notebook: chapter_view_state::IsSet,
     St::Record: chapter_view_state::IsSet,
+    St::Authors: chapter_view_state::IsSet,
+    St::IndexedAt: chapter_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ChapterView<S> {
@@ -3191,9 +3191,9 @@ pub mod entry_view_state {
     pub trait State: sealed::Sealed {
         type Cid;
         type IndexedAt;
-        type Authors;
         type Uri;
         type Record;
+        type Authors;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -3201,9 +3201,9 @@ pub mod entry_view_state {
     impl State for Empty {
         type Cid = Unset;
         type IndexedAt = Unset;
-        type Authors = Unset;
         type Uri = Unset;
         type Record = Unset;
+        type Authors = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
@@ -3211,9 +3211,9 @@ pub mod entry_view_state {
     impl<St: State> State for SetCid<St> {
         type Cid = Set<members::cid>;
         type IndexedAt = St::IndexedAt;
-        type Authors = St::Authors;
         type Uri = St::Uri;
         type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -3221,19 +3221,9 @@ pub mod entry_view_state {
     impl<St: State> State for SetIndexedAt<St> {
         type Cid = St::Cid;
         type IndexedAt = Set<members::indexed_at>;
-        type Authors = St::Authors;
-        type Uri = St::Uri;
-        type Record = St::Record;
-    }
-    ///State transition - sets the `authors` field to Set
-    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthors<St> {}
-    impl<St: State> State for SetAuthors<St> {
-        type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
-        type Authors = Set<members::authors>;
         type Uri = St::Uri;
         type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
@@ -3241,9 +3231,9 @@ pub mod entry_view_state {
     impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Authors = St::Authors;
         type Uri = Set<members::uri>;
         type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
@@ -3251,9 +3241,19 @@ pub mod entry_view_state {
     impl<St: State> State for SetRecord<St> {
         type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-        type Authors = St::Authors;
         type Uri = St::Uri;
         type Record = Set<members::record>;
+        type Authors = St::Authors;
+    }
+    ///State transition - sets the `authors` field to Set
+    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthors<St> {}
+    impl<St: State> State for SetAuthors<St> {
+        type Cid = St::Cid;
+        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
+        type Record = St::Record;
+        type Authors = Set<members::authors>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -3262,12 +3262,12 @@ pub mod entry_view_state {
         pub struct cid(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `authors` field
-        pub struct authors(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
     }
 }
 
@@ -3576,9 +3576,9 @@ where
     St: entry_view_state::State,
     St::Cid: entry_view_state::IsSet,
     St::IndexedAt: entry_view_state::IsSet,
-    St::Authors: entry_view_state::IsSet,
     St::Uri: entry_view_state::IsSet,
     St::Record: entry_view_state::IsSet,
+    St::Authors: entry_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EntryView<S> {
@@ -3777,37 +3777,37 @@ pub mod feed_notebook_context_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
         type Title;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Title = St::Title;
+        type Uri = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Uri = St::Uri;
         type Title = Set<members::title>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Title = St::Title;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -3896,8 +3896,8 @@ where
 impl<S: BosStr, St> FeedNotebookContextBuilder<S, St>
 where
     St: feed_notebook_context_state::State,
-    St::Uri: feed_notebook_context_state::IsSet,
     St::Title: feed_notebook_context_state::IsSet,
+    St::Uri: feed_notebook_context_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FeedNotebookContext<S> {
@@ -3932,85 +3932,85 @@ pub mod notebook_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Authors;
+        type Record;
         type IndexedAt;
         type Uri;
         type Cid;
-        type Record;
+        type Authors;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Authors = Unset;
+        type Record = Unset;
         type IndexedAt = Unset;
         type Uri = Unset;
         type Cid = Unset;
-        type Record = Unset;
+        type Authors = Unset;
     }
-    ///State transition - sets the `authors` field to Set
-    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthors<St> {}
-    impl<St: State> State for SetAuthors<St> {
-        type Authors = Set<members::authors>;
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Record = Set<members::record>;
         type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
         type Cid = St::Cid;
-        type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Authors = St::Authors;
+        type Record = St::Record;
         type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
         type Cid = St::Cid;
-        type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Authors = St::Authors;
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
         type Uri = Set<members::uri>;
         type Cid = St::Cid;
-        type Record = St::Record;
+        type Authors = St::Authors;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Authors = St::Authors;
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
         type Cid = Set<members::cid>;
-        type Record = St::Record;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
         type Authors = St::Authors;
+    }
+    ///State transition - sets the `authors` field to Set
+    pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthors<St> {}
+    impl<St: State> State for SetAuthors<St> {
+        type Record = St::Record;
         type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
         type Cid = St::Cid;
-        type Record = Set<members::record>;
+        type Authors = Set<members::authors>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `authors` field
-        pub struct authors(());
+        ///Marker type for the `record` field
+        pub struct record(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `record` field
-        pub struct record(());
+        ///Marker type for the `authors` field
+        pub struct authors(());
     }
 }
 
@@ -4341,11 +4341,11 @@ impl<S: BosStr, St: notebook_view_state::State> NotebookViewBuilder<S, St> {
 impl<S: BosStr, St> NotebookViewBuilder<S, St>
 where
     St: notebook_view_state::State,
-    St::Authors: notebook_view_state::IsSet,
+    St::Record: notebook_view_state::IsSet,
     St::IndexedAt: notebook_view_state::IsSet,
     St::Uri: notebook_view_state::IsSet,
     St::Cid: notebook_view_state::IsSet,
-    St::Record: notebook_view_state::IsSet,
+    St::Authors: notebook_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotebookView<S> {
@@ -4408,85 +4408,85 @@ pub mod page_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IndexedAt;
+        type Uri;
         type Cid;
         type Notebook;
-        type Uri;
         type Record;
+        type IndexedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IndexedAt = Unset;
+        type Uri = Unset;
         type Cid = Unset;
         type Notebook = Unset;
-        type Uri = Unset;
         type Record = Unset;
+        type IndexedAt = Unset;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
         type Notebook = St::Notebook;
-        type Uri = St::Uri;
         type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
         type Cid = Set<members::cid>;
         type Notebook = St::Notebook;
-        type Uri = St::Uri;
         type Record = St::Record;
+        type IndexedAt = St::IndexedAt;
     }
     ///State transition - sets the `notebook` field to Set
     pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotebook<St> {}
     impl<St: State> State for SetNotebook<St> {
-        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
         type Cid = St::Cid;
         type Notebook = Set<members::notebook>;
-        type Uri = St::Uri;
         type Record = St::Record;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Notebook = St::Notebook;
-        type Uri = Set<members::uri>;
-        type Record = St::Record;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
-        type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
         type Cid = St::Cid;
         type Notebook = St::Notebook;
-        type Uri = St::Uri;
         type Record = Set<members::record>;
+        type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Notebook = St::Notebook;
+        type Record = St::Record;
+        type IndexedAt = Set<members::indexed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
         ///Marker type for the `notebook` field
         pub struct notebook(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
     }
 }
 
@@ -4661,11 +4661,11 @@ where
 impl<S: BosStr, St> PageViewBuilder<S, St>
 where
     St: page_view_state::State,
-    St::IndexedAt: page_view_state::IsSet,
+    St::Uri: page_view_state::IsSet,
     St::Cid: page_view_state::IsSet,
     St::Notebook: page_view_state::IsSet,
-    St::Uri: page_view_state::IsSet,
     St::Record: page_view_state::IsSet,
+    St::IndexedAt: page_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PageView<S> {
@@ -4707,8 +4707,8 @@ pub mod permission_grant_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Scope;
         type Did;
+        type Scope;
         type Source;
         type GrantedAt;
     }
@@ -4716,26 +4716,26 @@ pub mod permission_grant_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Scope = Unset;
         type Did = Unset;
+        type Scope = Unset;
         type Source = Unset;
         type GrantedAt = Unset;
     }
-    ///State transition - sets the `scope` field to Set
-    pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetScope<St> {}
-    impl<St: State> State for SetScope<St> {
-        type Scope = Set<members::scope>;
-        type Did = St::Did;
-        type Source = St::Source;
-        type GrantedAt = St::GrantedAt;
-    }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Scope = St::Scope;
         type Did = Set<members::did>;
+        type Scope = St::Scope;
+        type Source = St::Source;
+        type GrantedAt = St::GrantedAt;
+    }
+    ///State transition - sets the `scope` field to Set
+    pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetScope<St> {}
+    impl<St: State> State for SetScope<St> {
+        type Did = St::Did;
+        type Scope = Set<members::scope>;
         type Source = St::Source;
         type GrantedAt = St::GrantedAt;
     }
@@ -4743,8 +4743,8 @@ pub mod permission_grant_state {
     pub struct SetSource<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSource<St> {}
     impl<St: State> State for SetSource<St> {
-        type Scope = St::Scope;
         type Did = St::Did;
+        type Scope = St::Scope;
         type Source = Set<members::source>;
         type GrantedAt = St::GrantedAt;
     }
@@ -4752,18 +4752,18 @@ pub mod permission_grant_state {
     pub struct SetGrantedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetGrantedAt<St> {}
     impl<St: State> State for SetGrantedAt<St> {
-        type Scope = St::Scope;
         type Did = St::Did;
+        type Scope = St::Scope;
         type Source = St::Source;
         type GrantedAt = Set<members::granted_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `scope` field
-        pub struct scope(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `scope` field
+        pub struct scope(());
         ///Marker type for the `source` field
         pub struct source(());
         ///Marker type for the `granted_at` field
@@ -4880,8 +4880,8 @@ where
 impl<S: BosStr, St> PermissionGrantBuilder<S, St>
 where
     St: permission_grant_state::State,
-    St::Scope: permission_grant_state::IsSet,
     St::Did: permission_grant_state::IsSet,
+    St::Scope: permission_grant_state::IsSet,
     St::Source: permission_grant_state::IsSet,
     St::GrantedAt: permission_grant_state::IsSet,
 {
@@ -5044,67 +5044,67 @@ pub mod published_version_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Uri;
-        type Publisher;
         type PublishedAt;
         type Cid;
+        type Publisher;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Uri = Unset;
-        type Publisher = Unset;
         type PublishedAt = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Publisher = St::Publisher;
-        type PublishedAt = St::PublishedAt;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `publisher` field to Set
-    pub struct SetPublisher<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPublisher<St> {}
-    impl<St: State> State for SetPublisher<St> {
-        type Uri = St::Uri;
-        type Publisher = Set<members::publisher>;
-        type PublishedAt = St::PublishedAt;
-        type Cid = St::Cid;
+        type Publisher = Unset;
+        type Uri = Unset;
     }
     ///State transition - sets the `published_at` field to Set
     pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublishedAt<St> {}
     impl<St: State> State for SetPublishedAt<St> {
-        type Uri = St::Uri;
-        type Publisher = St::Publisher;
         type PublishedAt = Set<members::published_at>;
         type Cid = St::Cid;
+        type Publisher = St::Publisher;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type Uri = St::Uri;
-        type Publisher = St::Publisher;
         type PublishedAt = St::PublishedAt;
         type Cid = Set<members::cid>;
+        type Publisher = St::Publisher;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `publisher` field to Set
+    pub struct SetPublisher<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPublisher<St> {}
+    impl<St: State> State for SetPublisher<St> {
+        type PublishedAt = St::PublishedAt;
+        type Cid = St::Cid;
+        type Publisher = Set<members::publisher>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type PublishedAt = St::PublishedAt;
+        type Cid = St::Cid;
+        type Publisher = St::Publisher;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `publisher` field
-        pub struct publisher(());
         ///Marker type for the `published_at` field
         pub struct published_at(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `publisher` field
+        pub struct publisher(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -5274,10 +5274,10 @@ where
 impl<S: BosStr, St> PublishedVersionViewBuilder<S, St>
 where
     St: published_version_view_state::State,
-    St::Uri: published_version_view_state::IsSet,
-    St::Publisher: published_version_view_state::IsSet,
     St::PublishedAt: published_version_view_state::IsSet,
     St::Cid: published_version_view_state::IsSet,
+    St::Publisher: published_version_view_state::IsSet,
+    St::Uri: published_version_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PublishedVersionView<S> {
@@ -5454,37 +5454,37 @@ pub mod reason_like_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type IndexedAt;
         type By;
+        type IndexedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type IndexedAt = Unset;
         type By = Unset;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
-        type By = St::By;
+        type IndexedAt = Unset;
     }
     ///State transition - sets the `by` field to Set
     pub struct SetBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBy<St> {}
     impl<St: State> State for SetBy<St> {
-        type IndexedAt = St::IndexedAt;
         type By = Set<members::by>;
+        type IndexedAt = St::IndexedAt;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type By = St::By;
+        type IndexedAt = Set<members::indexed_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
         ///Marker type for the `by` field
         pub struct by(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
     }
 }
 
@@ -5554,8 +5554,8 @@ where
 impl<S: BosStr, St> ReasonLikeBuilder<S, St>
 where
     St: reason_like_state::State,
-    St::IndexedAt: reason_like_state::IsSet,
     St::By: reason_like_state::IsSet,
+    St::IndexedAt: reason_like_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReasonLike<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs b/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs
index a901c766..d0484bb0 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/chapter.rs
@@ -132,50 +132,50 @@ pub mod chapter_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Authors;
-        type Notebook;
         type EntryList;
+        type Notebook;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Authors = Unset;
-        type Notebook = Unset;
         type EntryList = Unset;
+        type Notebook = Unset;
     }
     ///State transition - sets the `authors` field to Set
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
         type Authors = Set<members::authors>;
-        type Notebook = St::Notebook;
-        type EntryList = St::EntryList;
-    }
-    ///State transition - sets the `notebook` field to Set
-    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotebook<St> {}
-    impl<St: State> State for SetNotebook<St> {
-        type Authors = St::Authors;
-        type Notebook = Set<members::notebook>;
         type EntryList = St::EntryList;
+        type Notebook = St::Notebook;
     }
     ///State transition - sets the `entry_list` field to Set
     pub struct SetEntryList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEntryList<St> {}
     impl<St: State> State for SetEntryList<St> {
         type Authors = St::Authors;
-        type Notebook = St::Notebook;
         type EntryList = Set<members::entry_list>;
+        type Notebook = St::Notebook;
+    }
+    ///State transition - sets the `notebook` field to Set
+    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotebook<St> {}
+    impl<St: State> State for SetNotebook<St> {
+        type Authors = St::Authors;
+        type EntryList = St::EntryList;
+        type Notebook = Set<members::notebook>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `authors` field
         pub struct authors(());
-        ///Marker type for the `notebook` field
-        pub struct notebook(());
         ///Marker type for the `entry_list` field
         pub struct entry_list(());
+        ///Marker type for the `notebook` field
+        pub struct notebook(());
     }
 }
 
@@ -342,8 +342,8 @@ impl<S: BosStr, St> ChapterBuilder<S, St>
 where
     St: chapter_state::State,
     St::Authors: chapter_state::IsSet,
-    St::Notebook: chapter_state::IsSet,
     St::EntryList: chapter_state::IsSet,
+    St::Notebook: chapter_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Chapter<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/colour_scheme.rs b/crates/jacquard-api/src/sh_weaver/notebook/colour_scheme.rs
index 160286dd..b24b3569 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/colour_scheme.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/colour_scheme.rs
@@ -405,51 +405,51 @@ pub mod colour_scheme_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Variant;
         type Name;
         type Colours;
-        type Variant;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Variant = Unset;
         type Name = Unset;
         type Colours = Unset;
-        type Variant = Unset;
+    }
+    ///State transition - sets the `variant` field to Set
+    pub struct SetVariant<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVariant<St> {}
+    impl<St: State> State for SetVariant<St> {
+        type Variant = Set<members::variant>;
+        type Name = St::Name;
+        type Colours = St::Colours;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type Variant = St::Variant;
         type Name = Set<members::name>;
         type Colours = St::Colours;
-        type Variant = St::Variant;
     }
     ///State transition - sets the `colours` field to Set
     pub struct SetColours<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetColours<St> {}
     impl<St: State> State for SetColours<St> {
-        type Name = St::Name;
-        type Colours = Set<members::colours>;
         type Variant = St::Variant;
-    }
-    ///State transition - sets the `variant` field to Set
-    pub struct SetVariant<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVariant<St> {}
-    impl<St: State> State for SetVariant<St> {
         type Name = St::Name;
-        type Colours = St::Colours;
-        type Variant = Set<members::variant>;
+        type Colours = Set<members::colours>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `variant` field
+        pub struct variant(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `colours` field
         pub struct colours(());
-        ///Marker type for the `variant` field
-        pub struct variant(());
     }
 }
 
@@ -538,9 +538,9 @@ where
 impl<S: BosStr, St> ColourSchemeBuilder<S, St>
 where
     St: colour_scheme_state::State,
+    St::Variant: colour_scheme_state::IsSet,
     St::Name: colour_scheme_state::IsSet,
     St::Colours: colour_scheme_state::IsSet,
-    St::Variant: colour_scheme_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ColourScheme<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/entry.rs b/crates/jacquard-api/src/sh_weaver/notebook/entry.rs
index cacb4dfa..6a9ef66a 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/entry.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/entry.rs
@@ -351,67 +351,67 @@ pub mod entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Path;
         type Content;
-        type CreatedAt;
         type Title;
+        type Path;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Path = Unset;
         type Content = Unset;
-        type CreatedAt = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `path` field to Set
-    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPath<St> {}
-    impl<St: State> State for SetPath<St> {
-        type Path = Set<members::path>;
-        type Content = St::Content;
-        type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
+        type Path = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Path = St::Path;
         type Content = Set<members::content>;
-        type CreatedAt = St::CreatedAt;
         type Title = St::Title;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Path = St::Path;
-        type Content = St::Content;
-        type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
+        type Content = St::Content;
+        type Title = Set<members::title>;
         type Path = St::Path;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `path` field to Set
+    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPath<St> {}
+    impl<St: State> State for SetPath<St> {
         type Content = St::Content;
+        type Title = St::Title;
+        type Path = Set<members::path>;
         type CreatedAt = St::CreatedAt;
-        type Title = Set<members::title>;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Content = St::Content;
+        type Title = St::Title;
+        type Path = St::Path;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `path` field
-        pub struct path(());
         ///Marker type for the `content` field
         pub struct content(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `path` field
+        pub struct path(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -611,10 +611,10 @@ impl<S: BosStr, St: entry_state::State> EntryBuilder<S, St> {
 impl<S: BosStr, St> EntryBuilder<S, St>
 where
     St: entry_state::State,
-    St::Path: entry_state::IsSet,
     St::Content: entry_state::IsSet,
-    St::CreatedAt: entry_state::IsSet,
     St::Title: entry_state::IsSet,
+    St::Path: entry_state::IsSet,
+    St::CreatedAt: entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Entry<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/get_notebook_by_title.rs b/crates/jacquard-api/src/sh_weaver/notebook/get_notebook_by_title.rs
index 2d209d04..9cac5c41 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/get_notebook_by_title.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/get_notebook_by_title.rs
@@ -112,37 +112,37 @@ pub mod get_notebook_by_title_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Actor;
         type Title;
+        type Actor;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Actor = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `actor` field to Set
-    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActor<St> {}
-    impl<St: State> State for SetActor<St> {
-        type Actor = Set<members::actor>;
-        type Title = St::Title;
+        type Actor = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Actor = St::Actor;
         type Title = Set<members::title>;
+        type Actor = St::Actor;
+    }
+    ///State transition - sets the `actor` field to Set
+    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActor<St> {}
+    impl<St: State> State for SetActor<St> {
+        type Title = St::Title;
+        type Actor = Set<members::actor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `actor` field
-        pub struct actor(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `actor` field
+        pub struct actor(());
     }
 }
 
@@ -212,8 +212,8 @@ where
 impl<S: BosStr, St> GetNotebookByTitleBuilder<S, St>
 where
     St: get_notebook_by_title_state::State,
-    St::Actor: get_notebook_by_title_state::IsSet,
     St::Title: get_notebook_by_title_state::IsSet,
+    St::Actor: get_notebook_by_title_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetNotebookByTitle<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/page.rs b/crates/jacquard-api/src/sh_weaver/notebook/page.rs
index 815c8907..a66a97da 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/page.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/page.rs
@@ -124,50 +124,50 @@ pub mod page_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Authors;
-        type Notebook;
         type EntryList;
+        type Notebook;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Authors = Unset;
-        type Notebook = Unset;
         type EntryList = Unset;
+        type Notebook = Unset;
     }
     ///State transition - sets the `authors` field to Set
     pub struct SetAuthors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthors<St> {}
     impl<St: State> State for SetAuthors<St> {
         type Authors = Set<members::authors>;
-        type Notebook = St::Notebook;
-        type EntryList = St::EntryList;
-    }
-    ///State transition - sets the `notebook` field to Set
-    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetNotebook<St> {}
-    impl<St: State> State for SetNotebook<St> {
-        type Authors = St::Authors;
-        type Notebook = Set<members::notebook>;
         type EntryList = St::EntryList;
+        type Notebook = St::Notebook;
     }
     ///State transition - sets the `entry_list` field to Set
     pub struct SetEntryList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEntryList<St> {}
     impl<St: State> State for SetEntryList<St> {
         type Authors = St::Authors;
-        type Notebook = St::Notebook;
         type EntryList = Set<members::entry_list>;
+        type Notebook = St::Notebook;
+    }
+    ///State transition - sets the `notebook` field to Set
+    pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetNotebook<St> {}
+    impl<St: State> State for SetNotebook<St> {
+        type Authors = St::Authors;
+        type EntryList = St::EntryList;
+        type Notebook = Set<members::notebook>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `authors` field
         pub struct authors(());
-        ///Marker type for the `notebook` field
-        pub struct notebook(());
         ///Marker type for the `entry_list` field
         pub struct entry_list(());
+        ///Marker type for the `notebook` field
+        pub struct notebook(());
     }
 }
 
@@ -283,8 +283,8 @@ impl<S: BosStr, St> PageBuilder<S, St>
 where
     St: page_state::State,
     St::Authors: page_state::IsSet,
-    St::Notebook: page_state::IsSet,
     St::EntryList: page_state::IsSet,
+    St::Notebook: page_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Page<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/resolve_entry.rs b/crates/jacquard-api/src/sh_weaver/notebook/resolve_entry.rs
index b948f3a3..485974b0 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/resolve_entry.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/resolve_entry.rs
@@ -125,51 +125,51 @@ pub mod resolve_entry_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Entry;
         type Notebook;
         type Actor;
-        type Entry;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Entry = Unset;
         type Notebook = Unset;
         type Actor = Unset;
-        type Entry = Unset;
+    }
+    ///State transition - sets the `entry` field to Set
+    pub struct SetEntry<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEntry<St> {}
+    impl<St: State> State for SetEntry<St> {
+        type Entry = Set<members::entry>;
+        type Notebook = St::Notebook;
+        type Actor = St::Actor;
     }
     ///State transition - sets the `notebook` field to Set
     pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotebook<St> {}
     impl<St: State> State for SetNotebook<St> {
+        type Entry = St::Entry;
         type Notebook = Set<members::notebook>;
         type Actor = St::Actor;
-        type Entry = St::Entry;
     }
     ///State transition - sets the `actor` field to Set
     pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActor<St> {}
     impl<St: State> State for SetActor<St> {
-        type Notebook = St::Notebook;
-        type Actor = Set<members::actor>;
         type Entry = St::Entry;
-    }
-    ///State transition - sets the `entry` field to Set
-    pub struct SetEntry<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEntry<St> {}
-    impl<St: State> State for SetEntry<St> {
         type Notebook = St::Notebook;
-        type Actor = St::Actor;
-        type Entry = Set<members::entry>;
+        type Actor = Set<members::actor>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `entry` field
+        pub struct entry(());
         ///Marker type for the `notebook` field
         pub struct notebook(());
         ///Marker type for the `actor` field
         pub struct actor(());
-        ///Marker type for the `entry` field
-        pub struct entry(());
     }
 }
 
@@ -258,9 +258,9 @@ where
 impl<S: BosStr, St> ResolveEntryBuilder<S, St>
 where
     St: resolve_entry_state::State,
+    St::Entry: resolve_entry_state::IsSet,
     St::Notebook: resolve_entry_state::IsSet,
     St::Actor: resolve_entry_state::IsSet,
-    St::Entry: resolve_entry_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ResolveEntry<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notebook/theme.rs b/crates/jacquard-api/src/sh_weaver/notebook/theme.rs
index 3c5740c3..90406380 100644
--- a/crates/jacquard-api/src/sh_weaver/notebook/theme.rs
+++ b/crates/jacquard-api/src/sh_weaver/notebook/theme.rs
@@ -345,51 +345,51 @@ pub mod code_theme_file_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Content;
         type Name;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Content = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Content = St::Content;
-        type Name = St::Name;
+        type Did = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Did = St::Did;
         type Content = Set<members::content>;
         type Name = St::Name;
+        type Did = St::Did;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Did = St::Did;
         type Content = St::Content;
         type Name = Set<members::name>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Content = St::Content;
+        type Name = St::Name;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `content` field
         pub struct content(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -478,9 +478,9 @@ where
 impl<S: BosStr, St> CodeThemeFileBuilder<S, St>
 where
     St: code_theme_file_state::State,
-    St::Did: code_theme_file_state::IsSet,
     St::Content: code_theme_file_state::IsSet,
     St::Name: code_theme_file_state::IsSet,
+    St::Did: code_theme_file_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CodeThemeFile<S> {
@@ -897,51 +897,51 @@ pub mod font_file_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Did;
         type Content;
         type Name;
-        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Did = Unset;
         type Content = Unset;
         type Name = Unset;
-        type Did = Unset;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Did = Set<members::did>;
+        type Content = St::Content;
+        type Name = St::Name;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
+        type Did = St::Did;
         type Content = Set<members::content>;
         type Name = St::Name;
-        type Did = St::Did;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Content = St::Content;
-        type Name = Set<members::name>;
         type Did = St::Did;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
         type Content = St::Content;
-        type Name = St::Name;
-        type Did = Set<members::did>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `content` field
         pub struct content(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `did` field
-        pub struct did(());
     }
 }
 
@@ -1030,9 +1030,9 @@ where
 impl<S: BosStr, St> FontFileBuilder<S, St>
 where
     St: font_file_state::State,
+    St::Did: font_file_state::IsSet,
     St::Content: font_file_state::IsSet,
     St::Name: font_file_state::IsSet,
-    St::Did: font_file_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FontFile<S> {
@@ -1084,50 +1084,50 @@ pub mod theme_fonts_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Heading;
-        type Monospace;
         type Body;
+        type Monospace;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Heading = Unset;
-        type Monospace = Unset;
         type Body = Unset;
+        type Monospace = Unset;
     }
     ///State transition - sets the `heading` field to Set
     pub struct SetHeading<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeading<St> {}
     impl<St: State> State for SetHeading<St> {
         type Heading = Set<members::heading>;
-        type Monospace = St::Monospace;
-        type Body = St::Body;
-    }
-    ///State transition - sets the `monospace` field to Set
-    pub struct SetMonospace<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMonospace<St> {}
-    impl<St: State> State for SetMonospace<St> {
-        type Heading = St::Heading;
-        type Monospace = Set<members::monospace>;
         type Body = St::Body;
+        type Monospace = St::Monospace;
     }
     ///State transition - sets the `body` field to Set
     pub struct SetBody<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBody<St> {}
     impl<St: State> State for SetBody<St> {
         type Heading = St::Heading;
-        type Monospace = St::Monospace;
         type Body = Set<members::body>;
+        type Monospace = St::Monospace;
+    }
+    ///State transition - sets the `monospace` field to Set
+    pub struct SetMonospace<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMonospace<St> {}
+    impl<St: State> State for SetMonospace<St> {
+        type Heading = St::Heading;
+        type Body = St::Body;
+        type Monospace = Set<members::monospace>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `heading` field
         pub struct heading(());
-        ///Marker type for the `monospace` field
-        pub struct monospace(());
         ///Marker type for the `body` field
         pub struct body(());
+        ///Marker type for the `monospace` field
+        pub struct monospace(());
     }
 }
 
@@ -1221,8 +1221,8 @@ impl<S: BosStr, St> ThemeFontsBuilder<S, St>
 where
     St: theme_fonts_state::State,
     St::Heading: theme_fonts_state::IsSet,
-    St::Monospace: theme_fonts_state::IsSet,
     St::Body: theme_fonts_state::IsSet,
+    St::Monospace: theme_fonts_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ThemeFonts<S> {
@@ -1272,105 +1272,105 @@ pub mod theme_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Spacing;
+        type DarkScheme;
         type LightScheme;
+        type Fonts;
+        type Spacing;
         type DarkCodeTheme;
         type LightCodeTheme;
-        type DarkScheme;
-        type Fonts;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Spacing = Unset;
+        type DarkScheme = Unset;
         type LightScheme = Unset;
+        type Fonts = Unset;
+        type Spacing = Unset;
         type DarkCodeTheme = Unset;
         type LightCodeTheme = Unset;
-        type DarkScheme = Unset;
-        type Fonts = Unset;
     }
-    ///State transition - sets the `spacing` field to Set
-    pub struct SetSpacing<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSpacing<St> {}
-    impl<St: State> State for SetSpacing<St> {
-        type Spacing = Set<members::spacing>;
+    ///State transition - sets the `dark_scheme` field to Set
+    pub struct SetDarkScheme<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDarkScheme<St> {}
+    impl<St: State> State for SetDarkScheme<St> {
+        type DarkScheme = Set<members::dark_scheme>;
         type LightScheme = St::LightScheme;
+        type Fonts = St::Fonts;
+        type Spacing = St::Spacing;
         type DarkCodeTheme = St::DarkCodeTheme;
         type LightCodeTheme = St::LightCodeTheme;
-        type DarkScheme = St::DarkScheme;
-        type Fonts = St::Fonts;
     }
     ///State transition - sets the `light_scheme` field to Set
     pub struct SetLightScheme<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLightScheme<St> {}
     impl<St: State> State for SetLightScheme<St> {
-        type Spacing = St::Spacing;
+        type DarkScheme = St::DarkScheme;
         type LightScheme = Set<members::light_scheme>;
+        type Fonts = St::Fonts;
+        type Spacing = St::Spacing;
         type DarkCodeTheme = St::DarkCodeTheme;
         type LightCodeTheme = St::LightCodeTheme;
+    }
+    ///State transition - sets the `fonts` field to Set
+    pub struct SetFonts<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFonts<St> {}
+    impl<St: State> State for SetFonts<St> {
         type DarkScheme = St::DarkScheme;
+        type LightScheme = St::LightScheme;
+        type Fonts = Set<members::fonts>;
+        type Spacing = St::Spacing;
+        type DarkCodeTheme = St::DarkCodeTheme;
+        type LightCodeTheme = St::LightCodeTheme;
+    }
+    ///State transition - sets the `spacing` field to Set
+    pub struct SetSpacing<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSpacing<St> {}
+    impl<St: State> State for SetSpacing<St> {
+        type DarkScheme = St::DarkScheme;
+        type LightScheme = St::LightScheme;
         type Fonts = St::Fonts;
+        type Spacing = Set<members::spacing>;
+        type DarkCodeTheme = St::DarkCodeTheme;
+        type LightCodeTheme = St::LightCodeTheme;
     }
     ///State transition - sets the `dark_code_theme` field to Set
     pub struct SetDarkCodeTheme<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDarkCodeTheme<St> {}
     impl<St: State> State for SetDarkCodeTheme<St> {
-        type Spacing = St::Spacing;
+        type DarkScheme = St::DarkScheme;
         type LightScheme = St::LightScheme;
+        type Fonts = St::Fonts;
+        type Spacing = St::Spacing;
         type DarkCodeTheme = Set<members::dark_code_theme>;
         type LightCodeTheme = St::LightCodeTheme;
-        type DarkScheme = St::DarkScheme;
-        type Fonts = St::Fonts;
     }
     ///State transition - sets the `light_code_theme` field to Set
     pub struct SetLightCodeTheme<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLightCodeTheme<St> {}
     impl<St: State> State for SetLightCodeTheme<St> {
-        type Spacing = St::Spacing;
-        type LightScheme = St::LightScheme;
-        type DarkCodeTheme = St::DarkCodeTheme;
-        type LightCodeTheme = Set<members::light_code_theme>;
         type DarkScheme = St::DarkScheme;
-        type Fonts = St::Fonts;
-    }
-    ///State transition - sets the `dark_scheme` field to Set
-    pub struct SetDarkScheme<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDarkScheme<St> {}
-    impl<St: State> State for SetDarkScheme<St> {
-        type Spacing = St::Spacing;
         type LightScheme = St::LightScheme;
-        type DarkCodeTheme = St::DarkCodeTheme;
-        type LightCodeTheme = St::LightCodeTheme;
-        type DarkScheme = Set<members::dark_scheme>;
         type Fonts = St::Fonts;
-    }
-    ///State transition - sets the `fonts` field to Set
-    pub struct SetFonts<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFonts<St> {}
-    impl<St: State> State for SetFonts<St> {
         type Spacing = St::Spacing;
-        type LightScheme = St::LightScheme;
         type DarkCodeTheme = St::DarkCodeTheme;
-        type LightCodeTheme = St::LightCodeTheme;
-        type DarkScheme = St::DarkScheme;
-        type Fonts = Set<members::fonts>;
+        type LightCodeTheme = Set<members::light_code_theme>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `spacing` field
-        pub struct spacing(());
+        ///Marker type for the `dark_scheme` field
+        pub struct dark_scheme(());
         ///Marker type for the `light_scheme` field
         pub struct light_scheme(());
+        ///Marker type for the `fonts` field
+        pub struct fonts(());
+        ///Marker type for the `spacing` field
+        pub struct spacing(());
         ///Marker type for the `dark_code_theme` field
         pub struct dark_code_theme(());
         ///Marker type for the `light_code_theme` field
         pub struct light_code_theme(());
-        ///Marker type for the `dark_scheme` field
-        pub struct dark_scheme(());
-        ///Marker type for the `fonts` field
-        pub struct fonts(());
     }
 }
 
@@ -1537,12 +1537,12 @@ where
 impl<S: BosStr, St> ThemeBuilder<S, St>
 where
     St: theme_state::State,
-    St::Spacing: theme_state::IsSet,
+    St::DarkScheme: theme_state::IsSet,
     St::LightScheme: theme_state::IsSet,
+    St::Fonts: theme_state::IsSet,
+    St::Spacing: theme_state::IsSet,
     St::DarkCodeTheme: theme_state::IsSet,
     St::LightCodeTheme: theme_state::IsSet,
-    St::DarkScheme: theme_state::IsSet,
-    St::Fonts: theme_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Theme<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/notification.rs b/crates/jacquard-api/src/sh_weaver/notification.rs
index 0b9d1e37..943cb49d 100644
--- a/crates/jacquard-api/src/sh_weaver/notification.rs
+++ b/crates/jacquard-api/src/sh_weaver/notification.rs
@@ -285,103 +285,103 @@ pub mod notification_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Cid;
+        type Uri;
         type Reason;
-        type IndexedAt;
         type IsRead;
-        type Uri;
-        type Cid;
+        type IndexedAt;
         type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Cid = Unset;
+        type Uri = Unset;
         type Reason = Unset;
-        type IndexedAt = Unset;
         type IsRead = Unset;
-        type Uri = Unset;
-        type Cid = Unset;
+        type IndexedAt = Unset;
         type Author = Unset;
     }
-    ///State transition - sets the `reason` field to Set
-    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReason<St> {}
-    impl<St: State> State for SetReason<St> {
-        type Reason = Set<members::reason>;
-        type IndexedAt = St::IndexedAt;
-        type IsRead = St::IsRead;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
         type Uri = St::Uri;
-        type Cid = St::Cid;
+        type Reason = St::Reason;
+        type IsRead = St::IsRead;
+        type IndexedAt = St::IndexedAt;
         type Author = St::Author;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Cid = St::Cid;
+        type Uri = Set<members::uri>;
         type Reason = St::Reason;
-        type IndexedAt = Set<members::indexed_at>;
         type IsRead = St::IsRead;
-        type Uri = St::Uri;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `reason` field to Set
+    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReason<St> {}
+    impl<St: State> State for SetReason<St> {
         type Cid = St::Cid;
+        type Uri = St::Uri;
+        type Reason = Set<members::reason>;
+        type IsRead = St::IsRead;
+        type IndexedAt = St::IndexedAt;
         type Author = St::Author;
     }
     ///State transition - sets the `is_read` field to Set
     pub struct SetIsRead<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIsRead<St> {}
     impl<St: State> State for SetIsRead<St> {
-        type Reason = St::Reason;
-        type IndexedAt = St::IndexedAt;
-        type IsRead = Set<members::is_read>;
-        type Uri = St::Uri;
         type Cid = St::Cid;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Uri = St::Uri;
         type Reason = St::Reason;
+        type IsRead = Set<members::is_read>;
         type IndexedAt = St::IndexedAt;
-        type IsRead = St::IsRead;
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
         type Author = St::Author;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
         type Reason = St::Reason;
-        type IndexedAt = St::IndexedAt;
         type IsRead = St::IsRead;
-        type Uri = St::Uri;
-        type Cid = Set<members::cid>;
+        type IndexedAt = Set<members::indexed_at>;
         type Author = St::Author;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
         type Reason = St::Reason;
-        type IndexedAt = St::IndexedAt;
         type IsRead = St::IsRead;
-        type Uri = St::Uri;
-        type Cid = St::Cid;
+        type IndexedAt = St::IndexedAt;
         type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `reason` field
         pub struct reason(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
         ///Marker type for the `is_read` field
         pub struct is_read(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `author` field
         pub struct author(());
     }
@@ -564,11 +564,11 @@ where
 impl<S: BosStr, St> NotificationBuilder<S, St>
 where
     St: notification_state::State,
+    St::Cid: notification_state::IsSet,
+    St::Uri: notification_state::IsSet,
     St::Reason: notification_state::IsSet,
-    St::IndexedAt: notification_state::IsSet,
     St::IsRead: notification_state::IsSet,
-    St::Uri: notification_state::IsSet,
-    St::Cid: notification_state::IsSet,
+    St::IndexedAt: notification_state::IsSet,
     St::Author: notification_state::IsSet,
 {
     /// Build the final struct.
@@ -863,85 +863,85 @@ pub mod notification_group_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Reason;
         type Actors;
         type Count;
-        type Subject;
         type MostRecentAt;
-        type Reason;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Reason = Unset;
         type Actors = Unset;
         type Count = Unset;
-        type Subject = Unset;
         type MostRecentAt = Unset;
-        type Reason = Unset;
+        type Subject = Unset;
+    }
+    ///State transition - sets the `reason` field to Set
+    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReason<St> {}
+    impl<St: State> State for SetReason<St> {
+        type Reason = Set<members::reason>;
+        type Actors = St::Actors;
+        type Count = St::Count;
+        type MostRecentAt = St::MostRecentAt;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `actors` field to Set
     pub struct SetActors<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActors<St> {}
     impl<St: State> State for SetActors<St> {
+        type Reason = St::Reason;
         type Actors = Set<members::actors>;
         type Count = St::Count;
-        type Subject = St::Subject;
         type MostRecentAt = St::MostRecentAt;
-        type Reason = St::Reason;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `count` field to Set
     pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCount<St> {}
     impl<St: State> State for SetCount<St> {
-        type Actors = St::Actors;
-        type Count = Set<members::count>;
-        type Subject = St::Subject;
-        type MostRecentAt = St::MostRecentAt;
         type Reason = St::Reason;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type Actors = St::Actors;
-        type Count = St::Count;
-        type Subject = Set<members::subject>;
+        type Count = Set<members::count>;
         type MostRecentAt = St::MostRecentAt;
-        type Reason = St::Reason;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `most_recent_at` field to Set
     pub struct SetMostRecentAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMostRecentAt<St> {}
     impl<St: State> State for SetMostRecentAt<St> {
+        type Reason = St::Reason;
         type Actors = St::Actors;
         type Count = St::Count;
-        type Subject = St::Subject;
         type MostRecentAt = Set<members::most_recent_at>;
-        type Reason = St::Reason;
+        type Subject = St::Subject;
     }
-    ///State transition - sets the `reason` field to Set
-    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReason<St> {}
-    impl<St: State> State for SetReason<St> {
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Reason = St::Reason;
         type Actors = St::Actors;
         type Count = St::Count;
-        type Subject = St::Subject;
         type MostRecentAt = St::MostRecentAt;
-        type Reason = Set<members::reason>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `reason` field
+        pub struct reason(());
         ///Marker type for the `actors` field
         pub struct actors(());
         ///Marker type for the `count` field
         pub struct count(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `most_recent_at` field
         pub struct most_recent_at(());
-        ///Marker type for the `reason` field
-        pub struct reason(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -1088,11 +1088,11 @@ where
 impl<S: BosStr, St> NotificationGroupBuilder<S, St>
 where
     St: notification_group_state::State,
+    St::Reason: notification_group_state::IsSet,
     St::Actors: notification_group_state::IsSet,
     St::Count: notification_group_state::IsSet,
-    St::Subject: notification_group_state::IsSet,
     St::MostRecentAt: notification_group_state::IsSet,
-    St::Reason: notification_group_state::IsSet,
+    St::Subject: notification_group_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotificationGroup<S> {
@@ -1133,51 +1133,51 @@ pub mod subscription_update_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type UpdatedAt;
         type Notebook;
         type NewEntries;
-        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type UpdatedAt = Unset;
         type Notebook = Unset;
         type NewEntries = Unset;
-        type UpdatedAt = Unset;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type UpdatedAt = Set<members::updated_at>;
+        type Notebook = St::Notebook;
+        type NewEntries = St::NewEntries;
     }
     ///State transition - sets the `notebook` field to Set
     pub struct SetNotebook<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotebook<St> {}
     impl<St: State> State for SetNotebook<St> {
+        type UpdatedAt = St::UpdatedAt;
         type Notebook = Set<members::notebook>;
         type NewEntries = St::NewEntries;
-        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `new_entries` field to Set
     pub struct SetNewEntries<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNewEntries<St> {}
     impl<St: State> State for SetNewEntries<St> {
-        type Notebook = St::Notebook;
-        type NewEntries = Set<members::new_entries>;
         type UpdatedAt = St::UpdatedAt;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
         type Notebook = St::Notebook;
-        type NewEntries = St::NewEntries;
-        type UpdatedAt = Set<members::updated_at>;
+        type NewEntries = Set<members::new_entries>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
         ///Marker type for the `notebook` field
         pub struct notebook(());
         ///Marker type for the `new_entries` field
         pub struct new_entries(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
     }
 }
 
@@ -1305,9 +1305,9 @@ impl<
 impl<S: BosStr, St> SubscriptionUpdateViewBuilder<S, St>
 where
     St: subscription_update_view_state::State,
+    St::UpdatedAt: subscription_update_view_state::IsSet,
     St::Notebook: subscription_update_view_state::IsSet,
     St::NewEntries: subscription_update_view_state::IsSet,
-    St::UpdatedAt: subscription_update_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubscriptionUpdateView<S> {
diff --git a/crates/jacquard-api/src/sh_weaver/publish/blob.rs b/crates/jacquard-api/src/sh_weaver/publish/blob.rs
index 7bca5588..b308249e 100644
--- a/crates/jacquard-api/src/sh_weaver/publish/blob.rs
+++ b/crates/jacquard-api/src/sh_weaver/publish/blob.rs
@@ -166,37 +166,37 @@ pub mod blob_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Path;
         type Upload;
+        type Path;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Path = Unset;
         type Upload = Unset;
-    }
-    ///State transition - sets the `path` field to Set
-    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPath<St> {}
-    impl<St: State> State for SetPath<St> {
-        type Path = Set<members::path>;
-        type Upload = St::Upload;
+        type Path = Unset;
     }
     ///State transition - sets the `upload` field to Set
     pub struct SetUpload<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpload<St> {}
     impl<St: State> State for SetUpload<St> {
-        type Path = St::Path;
         type Upload = Set<members::upload>;
+        type Path = St::Path;
+    }
+    ///State transition - sets the `path` field to Set
+    pub struct SetPath<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPath<St> {}
+    impl<St: State> State for SetPath<St> {
+        type Upload = St::Upload;
+        type Path = Set<members::path>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `path` field
-        pub struct path(());
         ///Marker type for the `upload` field
         pub struct upload(());
+        ///Marker type for the `path` field
+        pub struct path(());
     }
 }
 
@@ -266,8 +266,8 @@ where
 impl<S: BosStr, St> BlobBuilder<S, St>
 where
     St: blob_state::State,
-    St::Path: blob_state::IsSet,
     St::Upload: blob_state::IsSet,
+    St::Path: blob_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Blob<S> {
diff --git a/crates/jacquard-api/src/site_standard/document.rs b/crates/jacquard-api/src/site_standard/document.rs
index 39946c4b..046b7599 100644
--- a/crates/jacquard-api/src/site_standard/document.rs
+++ b/crates/jacquard-api/src/site_standard/document.rs
@@ -224,49 +224,49 @@ pub mod document_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type PublishedAt;
+        type Title;
         type Site;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type PublishedAt = Unset;
+        type Title = Unset;
         type Site = Unset;
     }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type PublishedAt = St::PublishedAt;
-        type Site = St::Site;
-    }
     ///State transition - sets the `published_at` field to Set
     pub struct SetPublishedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPublishedAt<St> {}
     impl<St: State> State for SetPublishedAt<St> {
-        type Title = St::Title;
         type PublishedAt = Set<members::published_at>;
+        type Title = St::Title;
+        type Site = St::Site;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type PublishedAt = St::PublishedAt;
+        type Title = Set<members::title>;
         type Site = St::Site;
     }
     ///State transition - sets the `site` field to Set
     pub struct SetSite<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSite<St> {}
     impl<St: State> State for SetSite<St> {
-        type Title = St::Title;
         type PublishedAt = St::PublishedAt;
+        type Title = St::Title;
         type Site = Set<members::site>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `published_at` field
         pub struct published_at(());
+        ///Marker type for the `title` field
+        pub struct title(());
         ///Marker type for the `site` field
         pub struct site(());
     }
@@ -515,8 +515,8 @@ impl<S: BosStr, St: document_state::State> DocumentBuilder<S, St> {
 impl<S: BosStr, St> DocumentBuilder<S, St>
 where
     St: document_state::State,
-    St::Title: document_state::IsSet,
     St::PublishedAt: document_state::IsSet,
+    St::Title: document_state::IsSet,
     St::Site: document_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/site_standard/publication.rs b/crates/jacquard-api/src/site_standard/publication.rs
index 860ee5d1..99c3c362 100644
--- a/crates/jacquard-api/src/site_standard/publication.rs
+++ b/crates/jacquard-api/src/site_standard/publication.rs
@@ -252,37 +252,37 @@ pub mod publication_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Url;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Url = St::Url;
+        type Name = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type Name = St::Name;
         type Url = Set<members::url>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Url = St::Url;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -431,8 +431,8 @@ where
 impl<S: BosStr, St> PublicationBuilder<S, St>
 where
     St: publication_state::State,
-    St::Name: publication_state::IsSet,
     St::Url: publication_state::IsSet,
+    St::Name: publication_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Publication<S> {
diff --git a/crates/jacquard-api/src/site_standard/theme/basic.rs b/crates/jacquard-api/src/site_standard/theme/basic.rs
index 97d05ed8..df42e7ef 100644
--- a/crates/jacquard-api/src/site_standard/theme/basic.rs
+++ b/crates/jacquard-api/src/site_standard/theme/basic.rs
@@ -62,66 +62,66 @@ pub mod basic_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Foreground;
+        type AccentForeground;
         type Accent;
         type Background;
-        type AccentForeground;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Foreground = Unset;
+        type AccentForeground = Unset;
         type Accent = Unset;
         type Background = Unset;
-        type AccentForeground = Unset;
     }
     ///State transition - sets the `foreground` field to Set
     pub struct SetForeground<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetForeground<St> {}
     impl<St: State> State for SetForeground<St> {
         type Foreground = Set<members::foreground>;
+        type AccentForeground = St::AccentForeground;
+        type Accent = St::Accent;
+        type Background = St::Background;
+    }
+    ///State transition - sets the `accent_foreground` field to Set
+    pub struct SetAccentForeground<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAccentForeground<St> {}
+    impl<St: State> State for SetAccentForeground<St> {
+        type Foreground = St::Foreground;
+        type AccentForeground = Set<members::accent_foreground>;
         type Accent = St::Accent;
         type Background = St::Background;
-        type AccentForeground = St::AccentForeground;
     }
     ///State transition - sets the `accent` field to Set
     pub struct SetAccent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAccent<St> {}
     impl<St: State> State for SetAccent<St> {
         type Foreground = St::Foreground;
+        type AccentForeground = St::AccentForeground;
         type Accent = Set<members::accent>;
         type Background = St::Background;
-        type AccentForeground = St::AccentForeground;
     }
     ///State transition - sets the `background` field to Set
     pub struct SetBackground<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBackground<St> {}
     impl<St: State> State for SetBackground<St> {
         type Foreground = St::Foreground;
-        type Accent = St::Accent;
-        type Background = Set<members::background>;
         type AccentForeground = St::AccentForeground;
-    }
-    ///State transition - sets the `accent_foreground` field to Set
-    pub struct SetAccentForeground<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAccentForeground<St> {}
-    impl<St: State> State for SetAccentForeground<St> {
-        type Foreground = St::Foreground;
         type Accent = St::Accent;
-        type Background = St::Background;
-        type AccentForeground = Set<members::accent_foreground>;
+        type Background = Set<members::background>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `foreground` field
         pub struct foreground(());
+        ///Marker type for the `accent_foreground` field
+        pub struct accent_foreground(());
         ///Marker type for the `accent` field
         pub struct accent(());
         ///Marker type for the `background` field
         pub struct background(());
-        ///Marker type for the `accent_foreground` field
-        pub struct accent_foreground(());
     }
 }
 
@@ -230,9 +230,9 @@ impl<S: BosStr, St> BasicBuilder<S, St>
 where
     St: basic_state::State,
     St::Foreground: basic_state::IsSet,
+    St::AccentForeground: basic_state::IsSet,
     St::Accent: basic_state::IsSet,
     St::Background: basic_state::IsSet,
-    St::AccentForeground: basic_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Basic<S> {
diff --git a/crates/jacquard-api/src/site_standard/theme/color.rs b/crates/jacquard-api/src/site_standard/theme/color.rs
index e11c346f..d12a1508 100644
--- a/crates/jacquard-api/src/site_standard/theme/color.rs
+++ b/crates/jacquard-api/src/site_standard/theme/color.rs
@@ -227,50 +227,50 @@ pub mod rgb_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type B;
-        type G;
         type R;
+        type G;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type B = Unset;
-        type G = Unset;
         type R = Unset;
+        type G = Unset;
     }
     ///State transition - sets the `b` field to Set
     pub struct SetB<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetB<St> {}
     impl<St: State> State for SetB<St> {
         type B = Set<members::b>;
-        type G = St::G;
-        type R = St::R;
-    }
-    ///State transition - sets the `g` field to Set
-    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetG<St> {}
-    impl<St: State> State for SetG<St> {
-        type B = St::B;
-        type G = Set<members::g>;
         type R = St::R;
+        type G = St::G;
     }
     ///State transition - sets the `r` field to Set
     pub struct SetR<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetR<St> {}
     impl<St: State> State for SetR<St> {
         type B = St::B;
-        type G = St::G;
         type R = Set<members::r>;
+        type G = St::G;
+    }
+    ///State transition - sets the `g` field to Set
+    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetG<St> {}
+    impl<St: State> State for SetG<St> {
+        type B = St::B;
+        type R = St::R;
+        type G = Set<members::g>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `b` field
         pub struct b(());
-        ///Marker type for the `g` field
-        pub struct g(());
         ///Marker type for the `r` field
         pub struct r(());
+        ///Marker type for the `g` field
+        pub struct g(());
     }
 }
 
@@ -351,8 +351,8 @@ impl<S: BosStr, St> RgbBuilder<S, St>
 where
     St: rgb_state::State,
     St::B: rgb_state::IsSet,
-    St::G: rgb_state::IsSet,
     St::R: rgb_state::IsSet,
+    St::G: rgb_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Rgb<S> {
@@ -490,65 +490,65 @@ pub mod rgba_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type G;
         type R;
         type B;
-        type G;
         type A;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type G = Unset;
         type R = Unset;
         type B = Unset;
-        type G = Unset;
         type A = Unset;
     }
+    ///State transition - sets the `g` field to Set
+    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetG<St> {}
+    impl<St: State> State for SetG<St> {
+        type G = Set<members::g>;
+        type R = St::R;
+        type B = St::B;
+        type A = St::A;
+    }
     ///State transition - sets the `r` field to Set
     pub struct SetR<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetR<St> {}
     impl<St: State> State for SetR<St> {
+        type G = St::G;
         type R = Set<members::r>;
         type B = St::B;
-        type G = St::G;
         type A = St::A;
     }
     ///State transition - sets the `b` field to Set
     pub struct SetB<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetB<St> {}
     impl<St: State> State for SetB<St> {
-        type R = St::R;
-        type B = Set<members::b>;
         type G = St::G;
-        type A = St::A;
-    }
-    ///State transition - sets the `g` field to Set
-    pub struct SetG<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetG<St> {}
-    impl<St: State> State for SetG<St> {
         type R = St::R;
-        type B = St::B;
-        type G = Set<members::g>;
+        type B = Set<members::b>;
         type A = St::A;
     }
     ///State transition - sets the `a` field to Set
     pub struct SetA<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetA<St> {}
     impl<St: State> State for SetA<St> {
+        type G = St::G;
         type R = St::R;
         type B = St::B;
-        type G = St::G;
         type A = Set<members::a>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `g` field
+        pub struct g(());
         ///Marker type for the `r` field
         pub struct r(());
         ///Marker type for the `b` field
         pub struct b(());
-        ///Marker type for the `g` field
-        pub struct g(());
         ///Marker type for the `a` field
         pub struct a(());
     }
@@ -646,9 +646,9 @@ where
 impl<S: BosStr, St> RgbaBuilder<S, St>
 where
     St: rgba_state::State,
+    St::G: rgba_state::IsSet,
     St::R: rgba_state::IsSet,
     St::B: rgba_state::IsSet,
-    St::G: rgba_state::IsSet,
     St::A: rgba_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/social_clippr/actor.rs b/crates/jacquard-api/src/social_clippr/actor.rs
index 9235d58b..a8c59864 100644
--- a/crates/jacquard-api/src/social_clippr/actor.rs
+++ b/crates/jacquard-api/src/social_clippr/actor.rs
@@ -252,51 +252,51 @@ pub mod profile_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
-        type Handle;
         type DisplayName;
+        type Handle;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
-        type Handle = Unset;
         type DisplayName = Unset;
+        type Handle = Unset;
+        type Did = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
+    ///State transition - sets the `display_name` field to Set
+    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
+    impl<St: State> State for SetDisplayName<St> {
+        type DisplayName = Set<members::display_name>;
         type Handle = St::Handle;
-        type DisplayName = St::DisplayName;
+        type Did = St::Did;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
-        type Handle = Set<members::handle>;
         type DisplayName = St::DisplayName;
-    }
-    ///State transition - sets the `display_name` field to Set
-    pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisplayName<St> {}
-    impl<St: State> State for SetDisplayName<St> {
+        type Handle = Set<members::handle>;
         type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type DisplayName = St::DisplayName;
         type Handle = St::Handle;
-        type DisplayName = Set<members::display_name>;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -431,9 +431,9 @@ where
 impl<S: BosStr, St> ProfileViewBuilder<S, St>
 where
     St: profile_view_state::State,
-    St::Did: profile_view_state::IsSet,
-    St::Handle: profile_view_state::IsSet,
     St::DisplayName: profile_view_state::IsSet,
+    St::Handle: profile_view_state::IsSet,
+    St::Did: profile_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileView<S> {
diff --git a/crates/jacquard-api/src/social_clippr/feed.rs b/crates/jacquard-api/src/social_clippr/feed.rs
index 6fc88086..f21e3fa7 100644
--- a/crates/jacquard-api/src/social_clippr/feed.rs
+++ b/crates/jacquard-api/src/social_clippr/feed.rs
@@ -112,85 +112,85 @@ pub mod clip_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type IndexedAt;
         type Author;
-        type Record;
-        type Uri;
         type Cid;
+        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type IndexedAt = Unset;
         type Author = Unset;
-        type Record = Unset;
-        type Uri = Unset;
         type Cid = Unset;
+        type Record = Unset;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+        type Cid = St::Cid;
+        type Record = St::Record;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
         type IndexedAt = Set<members::indexed_at>;
         type Author = St::Author;
-        type Record = St::Record;
-        type Uri = St::Uri;
         type Cid = St::Cid;
+        type Record = St::Record;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type IndexedAt = St::IndexedAt;
-        type Author = Set<members::author>;
-        type Record = St::Record;
         type Uri = St::Uri;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
         type IndexedAt = St::IndexedAt;
-        type Author = St::Author;
-        type Record = Set<members::record>;
-        type Uri = St::Uri;
+        type Author = Set<members::author>;
         type Cid = St::Cid;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type IndexedAt = St::IndexedAt;
-        type Author = St::Author;
         type Record = St::Record;
-        type Uri = Set<members::uri>;
-        type Cid = St::Cid;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
         type IndexedAt = St::IndexedAt;
         type Author = St::Author;
+        type Cid = Set<members::cid>;
         type Record = St::Record;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
         type Uri = St::Uri;
-        type Cid = Set<members::cid>;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
+        type Cid = St::Cid;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `record` field
-        pub struct record(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `record` field
+        pub struct record(());
     }
 }
 
@@ -323,11 +323,11 @@ where
 impl<S: BosStr, St> ClipViewBuilder<S, St>
 where
     St: clip_view_state::State,
+    St::Uri: clip_view_state::IsSet,
     St::IndexedAt: clip_view_state::IsSet,
     St::Author: clip_view_state::IsSet,
-    St::Record: clip_view_state::IsSet,
-    St::Uri: clip_view_state::IsSet,
     St::Cid: clip_view_state::IsSet,
+    St::Record: clip_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ClipView<S> {
@@ -511,85 +511,85 @@ pub mod tag_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Record;
-        type Author;
         type Cid;
-        type Uri;
         type IndexedAt;
+        type Author;
+        type Uri;
+        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Record = Unset;
-        type Author = Unset;
         type Cid = Unset;
-        type Uri = Unset;
         type IndexedAt = Unset;
+        type Author = Unset;
+        type Uri = Unset;
+        type Record = Unset;
     }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Record = Set<members::record>;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
+        type IndexedAt = St::IndexedAt;
         type Author = St::Author;
+        type Uri = St::Uri;
+        type Record = St::Record;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
         type Cid = St::Cid;
+        type IndexedAt = Set<members::indexed_at>;
+        type Author = St::Author;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
+        type Record = St::Record;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Record = St::Record;
-        type Author = Set<members::author>;
         type Cid = St::Cid;
-        type Uri = St::Uri;
         type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Record = St::Record;
-        type Author = St::Author;
-        type Cid = Set<members::cid>;
+        type Author = Set<members::author>;
         type Uri = St::Uri;
-        type IndexedAt = St::IndexedAt;
+        type Record = St::Record;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Record = St::Record;
-        type Author = St::Author;
         type Cid = St::Cid;
-        type Uri = Set<members::uri>;
         type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Record = St::Record;
         type Author = St::Author;
+        type Uri = Set<members::uri>;
+        type Record = St::Record;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
         type Cid = St::Cid;
+        type IndexedAt = St::IndexedAt;
+        type Author = St::Author;
         type Uri = St::Uri;
-        type IndexedAt = Set<members::indexed_at>;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `record` field
-        pub struct record(());
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
+        ///Marker type for the `author` field
+        pub struct author(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `record` field
+        pub struct record(());
     }
 }
 
@@ -722,11 +722,11 @@ where
 impl<S: BosStr, St> TagViewBuilder<S, St>
 where
     St: tag_view_state::State,
-    St::Record: tag_view_state::IsSet,
-    St::Author: tag_view_state::IsSet,
     St::Cid: tag_view_state::IsSet,
-    St::Uri: tag_view_state::IsSet,
     St::IndexedAt: tag_view_state::IsSet,
+    St::Author: tag_view_state::IsSet,
+    St::Uri: tag_view_state::IsSet,
+    St::Record: tag_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TagView<S> {
diff --git a/crates/jacquard-api/src/social_clippr/feed/clip.rs b/crates/jacquard-api/src/social_clippr/feed/clip.rs
index fceb3c1d..a931030d 100644
--- a/crates/jacquard-api/src/social_clippr/feed/clip.rs
+++ b/crates/jacquard-api/src/social_clippr/feed/clip.rs
@@ -247,85 +247,85 @@ pub mod clip_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Title;
-        type Url;
-        type Description;
         type Unlisted;
+        type CreatedAt;
+        type Description;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Title = Unset;
-        type Url = Unset;
-        type Description = Unset;
         type Unlisted = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Title = St::Title;
-        type Url = St::Url;
-        type Description = St::Description;
-        type Unlisted = St::Unlisted;
+        type CreatedAt = Unset;
+        type Description = Unset;
+        type Url = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = Set<members::title>;
-        type Url = St::Url;
-        type Description = St::Description;
         type Unlisted = St::Unlisted;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
         type CreatedAt = St::CreatedAt;
+        type Description = St::Description;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `unlisted` field to Set
+    pub struct SetUnlisted<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUnlisted<St> {}
+    impl<St: State> State for SetUnlisted<St> {
         type Title = St::Title;
-        type Url = Set<members::url>;
+        type Unlisted = Set<members::unlisted>;
+        type CreatedAt = St::CreatedAt;
         type Description = St::Description;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Title = St::Title;
         type Unlisted = St::Unlisted;
+        type CreatedAt = Set<members::created_at>;
+        type Description = St::Description;
+        type Url = St::Url;
     }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type CreatedAt = St::CreatedAt;
         type Title = St::Title;
-        type Url = St::Url;
-        type Description = Set<members::description>;
         type Unlisted = St::Unlisted;
-    }
-    ///State transition - sets the `unlisted` field to Set
-    pub struct SetUnlisted<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUnlisted<St> {}
-    impl<St: State> State for SetUnlisted<St> {
         type CreatedAt = St::CreatedAt;
-        type Title = St::Title;
+        type Description = Set<members::description>;
         type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type Title = St::Title;
+        type Unlisted = St::Unlisted;
+        type CreatedAt = St::CreatedAt;
         type Description = St::Description;
-        type Unlisted = Set<members::unlisted>;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `url` field
-        pub struct url(());
-        ///Marker type for the `description` field
-        pub struct description(());
         ///Marker type for the `unlisted` field
         pub struct unlisted(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `description` field
+        pub struct description(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -514,11 +514,11 @@ where
 impl<S: BosStr, St> ClipBuilder<S, St>
 where
     St: clip_state::State,
-    St::CreatedAt: clip_state::IsSet,
     St::Title: clip_state::IsSet,
-    St::Url: clip_state::IsSet,
-    St::Description: clip_state::IsSet,
     St::Unlisted: clip_state::IsSet,
+    St::CreatedAt: clip_state::IsSet,
+    St::Description: clip_state::IsSet,
+    St::Url: clip_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Clip<S> {
diff --git a/crates/jacquard-api/src/social_clippr/feed/tag.rs b/crates/jacquard-api/src/social_clippr/feed/tag.rs
index c43e4cde..25ddd5dc 100644
--- a/crates/jacquard-api/src/social_clippr/feed/tag.rs
+++ b/crates/jacquard-api/src/social_clippr/feed/tag.rs
@@ -188,37 +188,37 @@ pub mod tag_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -311,8 +311,8 @@ where
 impl<S: BosStr, St> TagBuilder<S, St>
 where
     St: tag_state::State,
-    St::CreatedAt: tag_state::IsSet,
     St::Name: tag_state::IsSet,
+    St::CreatedAt: tag_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Tag<S> {
diff --git a/crates/jacquard-api/src/social_colibri/approval.rs b/crates/jacquard-api/src/social_colibri/approval.rs
index b2c74544..1f3e14bc 100644
--- a/crates/jacquard-api/src/social_colibri/approval.rs
+++ b/crates/jacquard-api/src/social_colibri/approval.rs
@@ -114,49 +114,49 @@ pub mod approval_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Community;
         type CreatedAt;
+        type Community;
         type Membership;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Community = Unset;
         type CreatedAt = Unset;
+        type Community = Unset;
         type Membership = Unset;
     }
-    ///State transition - sets the `community` field to Set
-    pub struct SetCommunity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCommunity<St> {}
-    impl<St: State> State for SetCommunity<St> {
-        type Community = Set<members::community>;
-        type CreatedAt = St::CreatedAt;
-        type Membership = St::Membership;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Community = St::Community;
         type CreatedAt = Set<members::created_at>;
+        type Community = St::Community;
+        type Membership = St::Membership;
+    }
+    ///State transition - sets the `community` field to Set
+    pub struct SetCommunity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCommunity<St> {}
+    impl<St: State> State for SetCommunity<St> {
+        type CreatedAt = St::CreatedAt;
+        type Community = Set<members::community>;
         type Membership = St::Membership;
     }
     ///State transition - sets the `membership` field to Set
     pub struct SetMembership<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetMembership<St> {}
     impl<St: State> State for SetMembership<St> {
-        type Community = St::Community;
         type CreatedAt = St::CreatedAt;
+        type Community = St::Community;
         type Membership = Set<members::membership>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `community` field
-        pub struct community(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `community` field
+        pub struct community(());
         ///Marker type for the `membership` field
         pub struct membership(());
     }
@@ -247,8 +247,8 @@ where
 impl<S: BosStr, St> ApprovalBuilder<S, St>
 where
     St: approval_state::State,
-    St::Community: approval_state::IsSet,
     St::CreatedAt: approval_state::IsSet,
+    St::Community: approval_state::IsSet,
     St::Membership: approval_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/social_drydown/fragrance.rs b/crates/jacquard-api/src/social_drydown/fragrance.rs
index ac5ad67d..ea767e95 100644
--- a/crates/jacquard-api/src/social_drydown/fragrance.rs
+++ b/crates/jacquard-api/src/social_drydown/fragrance.rs
@@ -163,50 +163,50 @@ pub mod fragrance_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Name;
-        type CreatedAt;
         type House;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Name = Unset;
-        type CreatedAt = Unset;
         type House = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
         type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
-        type House = St::House;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
-        type CreatedAt = Set<members::created_at>;
         type House = St::House;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `house` field to Set
     pub struct SetHouse<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHouse<St> {}
     impl<St: State> State for SetHouse<St> {
         type Name = St::Name;
-        type CreatedAt = St::CreatedAt;
         type House = Set<members::house>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type House = St::House;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `house` field
         pub struct house(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -328,8 +328,8 @@ impl<S: BosStr, St> FragranceBuilder<S, St>
 where
     St: fragrance_state::State,
     St::Name: fragrance_state::IsSet,
-    St::CreatedAt: fragrance_state::IsSet,
     St::House: fragrance_state::IsSet,
+    St::CreatedAt: fragrance_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Fragrance<S> {
diff --git a/crates/jacquard-api/src/social_drydown/house.rs b/crates/jacquard-api/src/social_drydown/house.rs
index dc0c6327..074181df 100644
--- a/crates/jacquard-api/src/social_drydown/house.rs
+++ b/crates/jacquard-api/src/social_drydown/house.rs
@@ -139,37 +139,37 @@ pub mod house_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -252,8 +252,8 @@ impl<S: BosStr, St: house_state::State> HouseBuilder<S, St> {
 impl<S: BosStr, St> HouseBuilder<S, St>
 where
     St: house_state::State,
-    St::CreatedAt: house_state::IsSet,
     St::Name: house_state::IsSet,
+    St::CreatedAt: house_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> House<S> {
diff --git a/crates/jacquard-api/src/social_drydown/review.rs b/crates/jacquard-api/src/social_drydown/review.rs
index 27dcc2be..a8740b1b 100644
--- a/crates/jacquard-api/src/social_drydown/review.rs
+++ b/crates/jacquard-api/src/social_drydown/review.rs
@@ -370,37 +370,37 @@ pub mod review_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Fragrance;
         type CreatedAt;
+        type Fragrance;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Fragrance = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `fragrance` field to Set
-    pub struct SetFragrance<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFragrance<St> {}
-    impl<St: State> State for SetFragrance<St> {
-        type Fragrance = Set<members::fragrance>;
-        type CreatedAt = St::CreatedAt;
+        type Fragrance = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Fragrance = St::Fragrance;
         type CreatedAt = Set<members::created_at>;
+        type Fragrance = St::Fragrance;
+    }
+    ///State transition - sets the `fragrance` field to Set
+    pub struct SetFragrance<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFragrance<St> {}
+    impl<St: State> State for SetFragrance<St> {
+        type CreatedAt = St::CreatedAt;
+        type Fragrance = Set<members::fragrance>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `fragrance` field
-        pub struct fragrance(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `fragrance` field
+        pub struct fragrance(());
     }
 }
 
@@ -746,8 +746,8 @@ impl<S: BosStr, St: review_state::State> ReviewBuilder<S, St> {
 impl<S: BosStr, St> ReviewBuilder<S, St>
 where
     St: review_state::State,
-    St::Fragrance: review_state::IsSet,
     St::CreatedAt: review_state::IsSet,
+    St::Fragrance: review_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Review<S> {
diff --git a/crates/jacquard-api/src/social_grain/actor.rs b/crates/jacquard-api/src/social_grain/actor.rs
index 9b41dd7a..a8c4d180 100644
--- a/crates/jacquard-api/src/social_grain/actor.rs
+++ b/crates/jacquard-api/src/social_grain/actor.rs
@@ -117,37 +117,37 @@ pub mod profile_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Handle;
         type Did;
+        type Handle;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Handle = Unset;
         type Did = Unset;
-    }
-    ///State transition - sets the `handle` field to Set
-    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHandle<St> {}
-    impl<St: State> State for SetHandle<St> {
-        type Handle = Set<members::handle>;
-        type Did = St::Did;
+        type Handle = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
-        type Handle = St::Handle;
         type Did = Set<members::did>;
+        type Handle = St::Handle;
+    }
+    ///State transition - sets the `handle` field to Set
+    pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHandle<St> {}
+    impl<St: State> State for SetHandle<St> {
+        type Did = St::Did;
+        type Handle = Set<members::handle>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `handle` field
-        pub struct handle(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `handle` field
+        pub struct handle(());
     }
 }
 
@@ -290,8 +290,8 @@ impl<S: BosStr, St: profile_view_state::State> ProfileViewBuilder<S, St> {
 impl<S: BosStr, St> ProfileViewBuilder<S, St>
 where
     St: profile_view_state::State,
-    St::Handle: profile_view_state::IsSet,
     St::Did: profile_view_state::IsSet,
+    St::Handle: profile_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ProfileView<S> {
diff --git a/crates/jacquard-api/src/social_grain/gallery.rs b/crates/jacquard-api/src/social_grain/gallery.rs
index 438fd238..1540e664 100644
--- a/crates/jacquard-api/src/social_grain/gallery.rs
+++ b/crates/jacquard-api/src/social_grain/gallery.rs
@@ -410,84 +410,84 @@ pub mod gallery_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Record;
+        type Creator;
         type IndexedAt;
-        type Cid;
         type Uri;
-        type Creator;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Record = Unset;
+        type Creator = Unset;
         type IndexedAt = Unset;
-        type Cid = Unset;
         type Uri = Unset;
-        type Creator = Unset;
+        type Cid = Unset;
     }
     ///State transition - sets the `record` field to Set
     pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRecord<St> {}
     impl<St: State> State for SetRecord<St> {
         type Record = Set<members::record>;
+        type Creator = St::Creator;
         type IndexedAt = St::IndexedAt;
+        type Uri = St::Uri;
         type Cid = St::Cid;
+    }
+    ///State transition - sets the `creator` field to Set
+    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreator<St> {}
+    impl<St: State> State for SetCreator<St> {
+        type Record = St::Record;
+        type Creator = Set<members::creator>;
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
-        type Creator = St::Creator;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
         type Record = St::Record;
-        type IndexedAt = Set<members::indexed_at>;
-        type Cid = St::Cid;
-        type Uri = St::Uri;
         type Creator = St::Creator;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Record = St::Record;
-        type IndexedAt = St::IndexedAt;
-        type Cid = Set<members::cid>;
+        type IndexedAt = Set<members::indexed_at>;
         type Uri = St::Uri;
-        type Creator = St::Creator;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
         type Record = St::Record;
+        type Creator = St::Creator;
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
-        type Creator = St::Creator;
+        type Cid = St::Cid;
     }
-    ///State transition - sets the `creator` field to Set
-    pub struct SetCreator<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreator<St> {}
-    impl<St: State> State for SetCreator<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Record = St::Record;
+        type Creator = St::Creator;
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Uri = St::Uri;
-        type Creator = Set<members::creator>;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `record` field
         pub struct record(());
+        ///Marker type for the `creator` field
+        pub struct creator(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `creator` field
-        pub struct creator(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -649,10 +649,10 @@ impl<S: BosStr, St> GalleryViewBuilder<S, St>
 where
     St: gallery_view_state::State,
     St::Record: gallery_view_state::IsSet,
+    St::Creator: gallery_view_state::IsSet,
     St::IndexedAt: gallery_view_state::IsSet,
-    St::Cid: gallery_view_state::IsSet,
     St::Uri: gallery_view_state::IsSet,
-    St::Creator: gallery_view_state::IsSet,
+    St::Cid: gallery_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GalleryView<S> {
diff --git a/crates/jacquard-api/src/social_grain/gallery/item.rs b/crates/jacquard-api/src/social_grain/gallery/item.rs
index ef818972..24b34cd4 100644
--- a/crates/jacquard-api/src/social_grain/gallery/item.rs
+++ b/crates/jacquard-api/src/social_grain/gallery/item.rs
@@ -120,51 +120,51 @@ pub mod item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Gallery;
-        type CreatedAt;
         type Item;
+        type CreatedAt;
+        type Gallery;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Gallery = Unset;
-        type CreatedAt = Unset;
         type Item = Unset;
+        type CreatedAt = Unset;
+        type Gallery = Unset;
     }
-    ///State transition - sets the `gallery` field to Set
-    pub struct SetGallery<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetGallery<St> {}
-    impl<St: State> State for SetGallery<St> {
-        type Gallery = Set<members::gallery>;
+    ///State transition - sets the `item` field to Set
+    pub struct SetItem<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetItem<St> {}
+    impl<St: State> State for SetItem<St> {
+        type Item = Set<members::item>;
         type CreatedAt = St::CreatedAt;
-        type Item = St::Item;
+        type Gallery = St::Gallery;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Gallery = St::Gallery;
-        type CreatedAt = Set<members::created_at>;
         type Item = St::Item;
-    }
-    ///State transition - sets the `item` field to Set
-    pub struct SetItem<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetItem<St> {}
-    impl<St: State> State for SetItem<St> {
+        type CreatedAt = Set<members::created_at>;
         type Gallery = St::Gallery;
+    }
+    ///State transition - sets the `gallery` field to Set
+    pub struct SetGallery<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetGallery<St> {}
+    impl<St: State> State for SetGallery<St> {
+        type Item = St::Item;
         type CreatedAt = St::CreatedAt;
-        type Item = Set<members::item>;
+        type Gallery = Set<members::gallery>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `gallery` field
-        pub struct gallery(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `item` field
         pub struct item(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `gallery` field
+        pub struct gallery(());
     }
 }
 
@@ -266,9 +266,9 @@ impl<S: BosStr, St: item_state::State> ItemBuilder<S, St> {
 impl<S: BosStr, St> ItemBuilder<S, St>
 where
     St: item_state::State,
-    St::Gallery: item_state::IsSet,
-    St::CreatedAt: item_state::IsSet,
     St::Item: item_state::IsSet,
+    St::CreatedAt: item_state::IsSet,
+    St::Gallery: item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Item<S> {
diff --git a/crates/jacquard-api/src/social_grain/photo.rs b/crates/jacquard-api/src/social_grain/photo.rs
index ac3b3af5..7cd45c34 100644
--- a/crates/jacquard-api/src/social_grain/photo.rs
+++ b/crates/jacquard-api/src/social_grain/photo.rs
@@ -247,37 +247,37 @@ pub mod photo_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Alt;
         type Photo;
+        type Alt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Alt = Unset;
         type Photo = Unset;
-    }
-    ///State transition - sets the `alt` field to Set
-    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAlt<St> {}
-    impl<St: State> State for SetAlt<St> {
-        type Alt = Set<members::alt>;
-        type Photo = St::Photo;
+        type Alt = Unset;
     }
     ///State transition - sets the `photo` field to Set
     pub struct SetPhoto<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPhoto<St> {}
     impl<St: State> State for SetPhoto<St> {
-        type Alt = St::Alt;
         type Photo = Set<members::photo>;
+        type Alt = St::Alt;
+    }
+    ///State transition - sets the `alt` field to Set
+    pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAlt<St> {}
+    impl<St: State> State for SetAlt<St> {
+        type Photo = St::Photo;
+        type Alt = Set<members::alt>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `alt` field
-        pub struct alt(());
         ///Marker type for the `photo` field
         pub struct photo(());
+        ///Marker type for the `alt` field
+        pub struct alt(());
     }
 }
 
@@ -373,8 +373,8 @@ where
 impl<S: BosStr, St> PhotoBuilder<S, St>
 where
     St: photo_state::State,
-    St::Alt: photo_state::IsSet,
     St::Photo: photo_state::IsSet,
+    St::Alt: photo_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Photo<S> {
@@ -1000,85 +1000,85 @@ pub mod photo_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
-        type Thumb;
         type Alt;
-        type Uri;
         type Fullsize;
+        type Uri;
+        type Cid;
+        type Thumb;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
-        type Thumb = Unset;
         type Alt = Unset;
-        type Uri = Unset;
         type Fullsize = Unset;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Thumb = St::Thumb;
-        type Alt = St::Alt;
-        type Uri = St::Uri;
-        type Fullsize = St::Fullsize;
-    }
-    ///State transition - sets the `thumb` field to Set
-    pub struct SetThumb<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetThumb<St> {}
-    impl<St: State> State for SetThumb<St> {
-        type Cid = St::Cid;
-        type Thumb = Set<members::thumb>;
-        type Alt = St::Alt;
-        type Uri = St::Uri;
-        type Fullsize = St::Fullsize;
+        type Uri = Unset;
+        type Cid = Unset;
+        type Thumb = Unset;
     }
     ///State transition - sets the `alt` field to Set
     pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAlt<St> {}
     impl<St: State> State for SetAlt<St> {
+        type Alt = Set<members::alt>;
+        type Fullsize = St::Fullsize;
+        type Uri = St::Uri;
         type Cid = St::Cid;
         type Thumb = St::Thumb;
-        type Alt = Set<members::alt>;
+    }
+    ///State transition - sets the `fullsize` field to Set
+    pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFullsize<St> {}
+    impl<St: State> State for SetFullsize<St> {
+        type Alt = St::Alt;
+        type Fullsize = Set<members::fullsize>;
         type Uri = St::Uri;
-        type Fullsize = St::Fullsize;
+        type Cid = St::Cid;
+        type Thumb = St::Thumb;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
+        type Alt = St::Alt;
+        type Fullsize = St::Fullsize;
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
         type Thumb = St::Thumb;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Alt = St::Alt;
-        type Uri = Set<members::uri>;
         type Fullsize = St::Fullsize;
-    }
-    ///State transition - sets the `fullsize` field to Set
-    pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFullsize<St> {}
-    impl<St: State> State for SetFullsize<St> {
-        type Cid = St::Cid;
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Thumb = St::Thumb;
+    }
+    ///State transition - sets the `thumb` field to Set
+    pub struct SetThumb<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetThumb<St> {}
+    impl<St: State> State for SetThumb<St> {
         type Alt = St::Alt;
+        type Fullsize = St::Fullsize;
         type Uri = St::Uri;
-        type Fullsize = Set<members::fullsize>;
+        type Cid = St::Cid;
+        type Thumb = Set<members::thumb>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `thumb` field
-        pub struct thumb(());
         ///Marker type for the `alt` field
         pub struct alt(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `fullsize` field
         pub struct fullsize(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `thumb` field
+        pub struct thumb(());
     }
 }
 
@@ -1239,11 +1239,11 @@ where
 impl<S: BosStr, St> PhotoViewBuilder<S, St>
 where
     St: photo_view_state::State,
-    St::Cid: photo_view_state::IsSet,
-    St::Thumb: photo_view_state::IsSet,
     St::Alt: photo_view_state::IsSet,
-    St::Uri: photo_view_state::IsSet,
     St::Fullsize: photo_view_state::IsSet,
+    St::Uri: photo_view_state::IsSet,
+    St::Cid: photo_view_state::IsSet,
+    St::Thumb: photo_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PhotoView<S> {
diff --git a/crates/jacquard-api/src/social_grain/photo/exif.rs b/crates/jacquard-api/src/social_grain/photo/exif.rs
index dc1b80e0..277c2745 100644
--- a/crates/jacquard-api/src/social_grain/photo/exif.rs
+++ b/crates/jacquard-api/src/social_grain/photo/exif.rs
@@ -132,37 +132,37 @@ pub mod exif_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Photo;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Photo = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Photo = St::Photo;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `photo` field to Set
     pub struct SetPhoto<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPhoto<St> {}
     impl<St: State> State for SetPhoto<St> {
-        type CreatedAt = St::CreatedAt;
         type Photo = Set<members::photo>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Photo = St::Photo;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `photo` field
         pub struct photo(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -388,8 +388,8 @@ where
 impl<S: BosStr, St> ExifBuilder<S, St>
 where
     St: exif_state::State,
-    St::CreatedAt: exif_state::IsSet,
     St::Photo: exif_state::IsSet,
+    St::CreatedAt: exif_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Exif<S> {
diff --git a/crates/jacquard-api/src/social_lexical/works/collectionitem.rs b/crates/jacquard-api/src/social_lexical/works/collectionitem.rs
index 4e69b73b..a0b06d28 100644
--- a/crates/jacquard-api/src/social_lexical/works/collectionitem.rs
+++ b/crates/jacquard-api/src/social_lexical/works/collectionitem.rs
@@ -116,51 +116,51 @@ pub mod collectionitem_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Work;
         type CreatedAt;
         type List;
+        type Work;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Work = Unset;
         type CreatedAt = Unset;
         type List = Unset;
-    }
-    ///State transition - sets the `work` field to Set
-    pub struct SetWork<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWork<St> {}
-    impl<St: State> State for SetWork<St> {
-        type Work = Set<members::work>;
-        type CreatedAt = St::CreatedAt;
-        type List = St::List;
+        type Work = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Work = St::Work;
         type CreatedAt = Set<members::created_at>;
         type List = St::List;
+        type Work = St::Work;
     }
     ///State transition - sets the `list` field to Set
     pub struct SetList<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetList<St> {}
     impl<St: State> State for SetList<St> {
-        type Work = St::Work;
         type CreatedAt = St::CreatedAt;
         type List = Set<members::list>;
+        type Work = St::Work;
+    }
+    ///State transition - sets the `work` field to Set
+    pub struct SetWork<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWork<St> {}
+    impl<St: State> State for SetWork<St> {
+        type CreatedAt = St::CreatedAt;
+        type List = St::List;
+        type Work = Set<members::work>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `work` field
-        pub struct work(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `list` field
         pub struct list(());
+        ///Marker type for the `work` field
+        pub struct work(());
     }
 }
 
@@ -249,9 +249,9 @@ where
 impl<S: BosStr, St> CollectionitemBuilder<S, St>
 where
     St: collectionitem_state::State,
-    St::Work: collectionitem_state::IsSet,
     St::CreatedAt: collectionitem_state::IsSet,
     St::List: collectionitem_state::IsSet,
+    St::Work: collectionitem_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collectionitem<S> {
diff --git a/crates/jacquard-api/src/social_lexical/works/identifiers.rs b/crates/jacquard-api/src/social_lexical/works/identifiers.rs
index 1e7421db..6d6bb1cc 100644
--- a/crates/jacquard-api/src/social_lexical/works/identifiers.rs
+++ b/crates/jacquard-api/src/social_lexical/works/identifiers.rs
@@ -333,37 +333,37 @@ pub mod identifiers_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Identifiers;
         type Work;
+        type Identifiers;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Identifiers = Unset;
         type Work = Unset;
-    }
-    ///State transition - sets the `identifiers` field to Set
-    pub struct SetIdentifiers<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIdentifiers<St> {}
-    impl<St: State> State for SetIdentifiers<St> {
-        type Identifiers = Set<members::identifiers>;
-        type Work = St::Work;
+        type Identifiers = Unset;
     }
     ///State transition - sets the `work` field to Set
     pub struct SetWork<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWork<St> {}
     impl<St: State> State for SetWork<St> {
-        type Identifiers = St::Identifiers;
         type Work = Set<members::work>;
+        type Identifiers = St::Identifiers;
+    }
+    ///State transition - sets the `identifiers` field to Set
+    pub struct SetIdentifiers<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIdentifiers<St> {}
+    impl<St: State> State for SetIdentifiers<St> {
+        type Work = St::Work;
+        type Identifiers = Set<members::identifiers>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `identifiers` field
-        pub struct identifiers(());
         ///Marker type for the `work` field
         pub struct work(());
+        ///Marker type for the `identifiers` field
+        pub struct identifiers(());
     }
 }
 
@@ -433,8 +433,8 @@ where
 impl<S: BosStr, St> IdentifiersBuilder<S, St>
 where
     St: identifiers_state::State,
-    St::Identifiers: identifiers_state::IsSet,
     St::Work: identifiers_state::IsSet,
+    St::Identifiers: identifiers_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Identifiers<S> {
diff --git a/crates/jacquard-api/src/social_lexical/works/work.rs b/crates/jacquard-api/src/social_lexical/works/work.rs
index 6a54efcf..98cd7ed6 100644
--- a/crates/jacquard-api/src/social_lexical/works/work.rs
+++ b/crates/jacquard-api/src/social_lexical/works/work.rs
@@ -283,37 +283,37 @@ pub mod work_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type WorkType;
         type Title;
+        type WorkType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type WorkType = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `work_type` field to Set
-    pub struct SetWorkType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWorkType<St> {}
-    impl<St: State> State for SetWorkType<St> {
-        type WorkType = Set<members::work_type>;
-        type Title = St::Title;
+        type WorkType = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type WorkType = St::WorkType;
         type Title = Set<members::title>;
+        type WorkType = St::WorkType;
+    }
+    ///State transition - sets the `work_type` field to Set
+    pub struct SetWorkType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWorkType<St> {}
+    impl<St: State> State for SetWorkType<St> {
+        type Title = St::Title;
+        type WorkType = Set<members::work_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `work_type` field
-        pub struct work_type(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `work_type` field
+        pub struct work_type(());
     }
 }
 
@@ -409,8 +409,8 @@ impl<S: BosStr, St: work_state::State> WorkBuilder<S, St> {
 impl<S: BosStr, St> WorkBuilder<S, St>
 where
     St: work_state::State,
-    St::WorkType: work_state::IsSet,
     St::Title: work_state::IsSet,
+    St::WorkType: work_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Work<S> {
diff --git a/crates/jacquard-api/src/social_octosphere/publication.rs b/crates/jacquard-api/src/social_octosphere/publication.rs
index 4bc12adf..4a7c2ab5 100644
--- a/crates/jacquard-api/src/social_octosphere/publication.rs
+++ b/crates/jacquard-api/src/social_octosphere/publication.rs
@@ -356,267 +356,267 @@ pub mod publication_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type ContentHtml;
+        type CreatedAt;
+        type UpdatedAt;
+        type LinkedTo;
+        type ContentText;
+        type LinkedFrom;
         type PublicationType;
         type Title;
-        type Citations;
         type OctopusId;
-        type LinkedTo;
+        type Citations;
         type Status;
-        type UpdatedAt;
-        type ContentHtml;
         type VersionId;
-        type LinkedFrom;
-        type ContentText;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type ContentHtml = Unset;
+        type CreatedAt = Unset;
+        type UpdatedAt = Unset;
+        type LinkedTo = Unset;
+        type ContentText = Unset;
+        type LinkedFrom = Unset;
         type PublicationType = Unset;
         type Title = Unset;
-        type Citations = Unset;
         type OctopusId = Unset;
-        type LinkedTo = Unset;
+        type Citations = Unset;
         type Status = Unset;
-        type UpdatedAt = Unset;
-        type ContentHtml = Unset;
         type VersionId = Unset;
-        type LinkedFrom = Unset;
-        type ContentText = Unset;
-        type CreatedAt = Unset;
     }
-    ///State transition - sets the `publication_type` field to Set
-    pub struct SetPublicationType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPublicationType<St> {}
-    impl<St: State> State for SetPublicationType<St> {
-        type PublicationType = Set<members::publication_type>;
-        type Title = St::Title;
-        type Citations = St::Citations;
-        type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
-        type Status = St::Status;
+    ///State transition - sets the `content_html` field to Set
+    pub struct SetContentHtml<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContentHtml<St> {}
+    impl<St: State> State for SetContentHtml<St> {
+        type ContentHtml = Set<members::content_html>;
+        type CreatedAt = St::CreatedAt;
         type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
-        type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
+        type LinkedTo = St::LinkedTo;
         type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
-        type Title = Set<members::title>;
-        type Citations = St::Citations;
+        type Title = St::Title;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `citations` field to Set
-    pub struct SetCitations<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCitations<St> {}
-    impl<St: State> State for SetCitations<St> {
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = Set<members::created_at>;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = Set<members::citations>;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `octopus_id` field to Set
-    pub struct SetOctopusId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOctopusId<St> {}
-    impl<St: State> State for SetOctopusId<St> {
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = Set<members::updated_at>;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
+        type OctopusId = St::OctopusId;
         type Citations = St::Citations;
-        type OctopusId = Set<members::octopus_id>;
-        type LinkedTo = St::LinkedTo;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `linked_to` field to Set
     pub struct SetLinkedTo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLinkedTo<St> {}
     impl<St: State> State for SetLinkedTo<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = Set<members::linked_to>;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = Set<members::linked_to>;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `status` field to Set
-    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStatus<St> {}
-    impl<St: State> State for SetStatus<St> {
+    ///State transition - sets the `content_text` field to Set
+    pub struct SetContentText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContentText<St> {}
+    impl<St: State> State for SetContentText<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = Set<members::content_text>;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
-        type Status = Set<members::status>;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
+        type Citations = St::Citations;
+        type Status = St::Status;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
+    ///State transition - sets the `linked_from` field to Set
+    pub struct SetLinkedFrom<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLinkedFrom<St> {}
+    impl<St: State> State for SetLinkedFrom<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = Set<members::linked_from>;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = Set<members::updated_at>;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `content_html` field to Set
-    pub struct SetContentHtml<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContentHtml<St> {}
-    impl<St: State> State for SetContentHtml<St> {
-        type PublicationType = St::PublicationType;
+    ///State transition - sets the `publication_type` field to Set
+    pub struct SetPublicationType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPublicationType<St> {}
+    impl<St: State> State for SetPublicationType<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
+        type PublicationType = Set<members::publication_type>;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = Set<members::content_html>;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `version_id` field to Set
-    pub struct SetVersionId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVersionId<St> {}
-    impl<St: State> State for SetVersionId<St> {
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
-        type Title = St::Title;
-        type Citations = St::Citations;
+        type Title = Set<members::title>;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = St::Citations;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
+        type VersionId = St::VersionId;
+    }
+    ///State transition - sets the `octopus_id` field to Set
+    pub struct SetOctopusId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOctopusId<St> {}
+    impl<St: State> State for SetOctopusId<St> {
         type ContentHtml = St::ContentHtml;
-        type VersionId = Set<members::version_id>;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = St::ContentText;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `linked_from` field to Set
-    pub struct SetLinkedFrom<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLinkedFrom<St> {}
-    impl<St: State> State for SetLinkedFrom<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
+        type OctopusId = Set<members::octopus_id>;
         type Citations = St::Citations;
-        type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = Set<members::linked_from>;
-        type ContentText = St::ContentText;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `content_text` field to Set
-    pub struct SetContentText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContentText<St> {}
-    impl<St: State> State for SetContentText<St> {
+    ///State transition - sets the `citations` field to Set
+    pub struct SetCitations<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCitations<St> {}
+    impl<St: State> State for SetCitations<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
+        type Citations = Set<members::citations>;
         type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
-        type ContentText = Set<members::content_text>;
-        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `status` field to Set
+    pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStatus<St> {}
+    impl<St: State> State for SetStatus<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
+        type ContentText = St::ContentText;
+        type LinkedFrom = St::LinkedFrom;
         type PublicationType = St::PublicationType;
         type Title = St::Title;
-        type Citations = St::Citations;
         type OctopusId = St::OctopusId;
-        type LinkedTo = St::LinkedTo;
-        type Status = St::Status;
-        type UpdatedAt = St::UpdatedAt;
-        type ContentHtml = St::ContentHtml;
+        type Citations = St::Citations;
+        type Status = Set<members::status>;
         type VersionId = St::VersionId;
-        type LinkedFrom = St::LinkedFrom;
+    }
+    ///State transition - sets the `version_id` field to Set
+    pub struct SetVersionId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVersionId<St> {}
+    impl<St: State> State for SetVersionId<St> {
+        type ContentHtml = St::ContentHtml;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
+        type LinkedTo = St::LinkedTo;
         type ContentText = St::ContentText;
-        type CreatedAt = Set<members::created_at>;
+        type LinkedFrom = St::LinkedFrom;
+        type PublicationType = St::PublicationType;
+        type Title = St::Title;
+        type OctopusId = St::OctopusId;
+        type Citations = St::Citations;
+        type Status = St::Status;
+        type VersionId = Set<members::version_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `content_html` field
+        pub struct content_html(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
+        ///Marker type for the `linked_to` field
+        pub struct linked_to(());
+        ///Marker type for the `content_text` field
+        pub struct content_text(());
+        ///Marker type for the `linked_from` field
+        pub struct linked_from(());
         ///Marker type for the `publication_type` field
         pub struct publication_type(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `citations` field
-        pub struct citations(());
         ///Marker type for the `octopus_id` field
         pub struct octopus_id(());
-        ///Marker type for the `linked_to` field
-        pub struct linked_to(());
+        ///Marker type for the `citations` field
+        pub struct citations(());
         ///Marker type for the `status` field
         pub struct status(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
-        ///Marker type for the `content_html` field
-        pub struct content_html(());
         ///Marker type for the `version_id` field
         pub struct version_id(());
-        ///Marker type for the `linked_from` field
-        pub struct linked_from(());
-        ///Marker type for the `content_text` field
-        pub struct content_text(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -962,18 +962,18 @@ where
 impl<S: BosStr, St> PublicationBuilder<S, St>
 where
     St: publication_state::State,
+    St::ContentHtml: publication_state::IsSet,
+    St::CreatedAt: publication_state::IsSet,
+    St::UpdatedAt: publication_state::IsSet,
+    St::LinkedTo: publication_state::IsSet,
+    St::ContentText: publication_state::IsSet,
+    St::LinkedFrom: publication_state::IsSet,
     St::PublicationType: publication_state::IsSet,
     St::Title: publication_state::IsSet,
-    St::Citations: publication_state::IsSet,
     St::OctopusId: publication_state::IsSet,
-    St::LinkedTo: publication_state::IsSet,
+    St::Citations: publication_state::IsSet,
     St::Status: publication_state::IsSet,
-    St::UpdatedAt: publication_state::IsSet,
-    St::ContentHtml: publication_state::IsSet,
     St::VersionId: publication_state::IsSet,
-    St::LinkedFrom: publication_state::IsSet,
-    St::ContentText: publication_state::IsSet,
-    St::CreatedAt: publication_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Publication<S> {
diff --git a/crates/jacquard-api/src/social_pace/daily/ring.rs b/crates/jacquard-api/src/social_pace/daily/ring.rs
index 9fed0276..b3e23075 100644
--- a/crates/jacquard-api/src/social_pace/daily/ring.rs
+++ b/crates/jacquard-api/src/social_pace/daily/ring.rs
@@ -124,10 +124,10 @@ pub mod ring_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type ExerciseGoal;
-        type StandHours;
         type StandGoal;
-        type CreatedAt;
         type Exercise;
+        type StandHours;
+        type CreatedAt;
         type MoveGoal;
         type Move;
     }
@@ -136,10 +136,10 @@ pub mod ring_state {
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type ExerciseGoal = Unset;
-        type StandHours = Unset;
         type StandGoal = Unset;
-        type CreatedAt = Unset;
         type Exercise = Unset;
+        type StandHours = Unset;
+        type CreatedAt = Unset;
         type MoveGoal = Unset;
         type Move = Unset;
     }
@@ -148,22 +148,10 @@ pub mod ring_state {
     impl<St: State> sealed::Sealed for SetExerciseGoal<St> {}
     impl<St: State> State for SetExerciseGoal<St> {
         type ExerciseGoal = Set<members::exercise_goal>;
-        type StandHours = St::StandHours;
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
         type Exercise = St::Exercise;
-        type MoveGoal = St::MoveGoal;
-        type Move = St::Move;
-    }
-    ///State transition - sets the `stand_hours` field to Set
-    pub struct SetStandHours<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStandHours<St> {}
-    impl<St: State> State for SetStandHours<St> {
-        type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = Set<members::stand_hours>;
-        type StandGoal = St::StandGoal;
+        type StandHours = St::StandHours;
         type CreatedAt = St::CreatedAt;
-        type Exercise = St::Exercise;
         type MoveGoal = St::MoveGoal;
         type Move = St::Move;
     }
@@ -172,22 +160,10 @@ pub mod ring_state {
     impl<St: State> sealed::Sealed for SetStandGoal<St> {}
     impl<St: State> State for SetStandGoal<St> {
         type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
         type StandGoal = Set<members::stand_goal>;
-        type CreatedAt = St::CreatedAt;
         type Exercise = St::Exercise;
-        type MoveGoal = St::MoveGoal;
-        type Move = St::Move;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type ExerciseGoal = St::ExerciseGoal;
         type StandHours = St::StandHours;
-        type StandGoal = St::StandGoal;
-        type CreatedAt = Set<members::created_at>;
-        type Exercise = St::Exercise;
+        type CreatedAt = St::CreatedAt;
         type MoveGoal = St::MoveGoal;
         type Move = St::Move;
     }
@@ -196,10 +172,34 @@ pub mod ring_state {
     impl<St: State> sealed::Sealed for SetExercise<St> {}
     impl<St: State> State for SetExercise<St> {
         type ExerciseGoal = St::ExerciseGoal;
+        type StandGoal = St::StandGoal;
+        type Exercise = Set<members::exercise>;
         type StandHours = St::StandHours;
+        type CreatedAt = St::CreatedAt;
+        type MoveGoal = St::MoveGoal;
+        type Move = St::Move;
+    }
+    ///State transition - sets the `stand_hours` field to Set
+    pub struct SetStandHours<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStandHours<St> {}
+    impl<St: State> State for SetStandHours<St> {
+        type ExerciseGoal = St::ExerciseGoal;
         type StandGoal = St::StandGoal;
+        type Exercise = St::Exercise;
+        type StandHours = Set<members::stand_hours>;
         type CreatedAt = St::CreatedAt;
-        type Exercise = Set<members::exercise>;
+        type MoveGoal = St::MoveGoal;
+        type Move = St::Move;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type ExerciseGoal = St::ExerciseGoal;
+        type StandGoal = St::StandGoal;
+        type Exercise = St::Exercise;
+        type StandHours = St::StandHours;
+        type CreatedAt = Set<members::created_at>;
         type MoveGoal = St::MoveGoal;
         type Move = St::Move;
     }
@@ -208,10 +208,10 @@ pub mod ring_state {
     impl<St: State> sealed::Sealed for SetMoveGoal<St> {}
     impl<St: State> State for SetMoveGoal<St> {
         type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
         type Exercise = St::Exercise;
+        type StandHours = St::StandHours;
+        type CreatedAt = St::CreatedAt;
         type MoveGoal = Set<members::move_goal>;
         type Move = St::Move;
     }
@@ -220,10 +220,10 @@ pub mod ring_state {
     impl<St: State> sealed::Sealed for SetMove<St> {}
     impl<St: State> State for SetMove<St> {
         type ExerciseGoal = St::ExerciseGoal;
-        type StandHours = St::StandHours;
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
         type Exercise = St::Exercise;
+        type StandHours = St::StandHours;
+        type CreatedAt = St::CreatedAt;
         type MoveGoal = St::MoveGoal;
         type Move = Set<members::r#move>;
     }
@@ -232,14 +232,14 @@ pub mod ring_state {
     pub mod members {
         ///Marker type for the `exercise_goal` field
         pub struct exercise_goal(());
-        ///Marker type for the `stand_hours` field
-        pub struct stand_hours(());
         ///Marker type for the `stand_goal` field
         pub struct stand_goal(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `exercise` field
         pub struct exercise(());
+        ///Marker type for the `stand_hours` field
+        pub struct stand_hours(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `move_goal` field
         pub struct move_goal(());
         ///Marker type for the `move` field
@@ -417,10 +417,10 @@ impl<S: BosStr, St> RingBuilder<S, St>
 where
     St: ring_state::State,
     St::ExerciseGoal: ring_state::IsSet,
-    St::StandHours: ring_state::IsSet,
     St::StandGoal: ring_state::IsSet,
-    St::CreatedAt: ring_state::IsSet,
     St::Exercise: ring_state::IsSet,
+    St::StandHours: ring_state::IsSet,
+    St::CreatedAt: ring_state::IsSet,
     St::MoveGoal: ring_state::IsSet,
     St::Move: ring_state::IsSet,
 {
diff --git a/crates/jacquard-api/src/social_pace/daily/step.rs b/crates/jacquard-api/src/social_pace/daily/step.rs
index 29071a7a..26f629d3 100644
--- a/crates/jacquard-api/src/social_pace/daily/step.rs
+++ b/crates/jacquard-api/src/social_pace/daily/step.rs
@@ -117,50 +117,50 @@ pub mod step_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Steps;
-        type UpdatedAt;
         type CreatedAt;
+        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Steps = Unset;
-        type UpdatedAt = Unset;
         type CreatedAt = Unset;
+        type UpdatedAt = Unset;
     }
     ///State transition - sets the `steps` field to Set
     pub struct SetSteps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSteps<St> {}
     impl<St: State> State for SetSteps<St> {
         type Steps = Set<members::steps>;
-        type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type Steps = St::Steps;
-        type UpdatedAt = Set<members::updated_at>;
         type CreatedAt = St::CreatedAt;
+        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Steps = St::Steps;
-        type UpdatedAt = St::UpdatedAt;
         type CreatedAt = Set<members::created_at>;
+        type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type Steps = St::Steps;
+        type CreatedAt = St::CreatedAt;
+        type UpdatedAt = Set<members::updated_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `steps` field
         pub struct steps(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
     }
 }
 
@@ -250,8 +250,8 @@ impl<S: BosStr, St> StepBuilder<S, St>
 where
     St: step_state::State,
     St::Steps: step_state::IsSet,
-    St::UpdatedAt: step_state::IsSet,
     St::CreatedAt: step_state::IsSet,
+    St::UpdatedAt: step_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Step<S> {
diff --git a/crates/jacquard-api/src/social_pace/feed/activity.rs b/crates/jacquard-api/src/social_pace/feed/activity.rs
index 08e225d4..dea6a416 100644
--- a/crates/jacquard-api/src/social_pace/feed/activity.rs
+++ b/crates/jacquard-api/src/social_pace/feed/activity.rs
@@ -180,67 +180,67 @@ pub mod activity_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type EndedAt;
         type Type;
         type CreatedAt;
         type StartedAt;
+        type EndedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type EndedAt = Unset;
         type Type = Unset;
         type CreatedAt = Unset;
         type StartedAt = Unset;
-    }
-    ///State transition - sets the `ended_at` field to Set
-    pub struct SetEndedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEndedAt<St> {}
-    impl<St: State> State for SetEndedAt<St> {
-        type EndedAt = Set<members::ended_at>;
-        type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
-        type StartedAt = St::StartedAt;
+        type EndedAt = Unset;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type EndedAt = St::EndedAt;
         type Type = Set<members::r#type>;
         type CreatedAt = St::CreatedAt;
         type StartedAt = St::StartedAt;
+        type EndedAt = St::EndedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type EndedAt = St::EndedAt;
         type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
         type StartedAt = St::StartedAt;
+        type EndedAt = St::EndedAt;
     }
     ///State transition - sets the `started_at` field to Set
     pub struct SetStartedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStartedAt<St> {}
     impl<St: State> State for SetStartedAt<St> {
-        type EndedAt = St::EndedAt;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type StartedAt = Set<members::started_at>;
+        type EndedAt = St::EndedAt;
+    }
+    ///State transition - sets the `ended_at` field to Set
+    pub struct SetEndedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEndedAt<St> {}
+    impl<St: State> State for SetEndedAt<St> {
+        type Type = St::Type;
+        type CreatedAt = St::CreatedAt;
+        type StartedAt = St::StartedAt;
+        type EndedAt = Set<members::ended_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `ended_at` field
-        pub struct ended_at(());
         ///Marker type for the `type` field
         pub struct r#type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `started_at` field
         pub struct started_at(());
+        ///Marker type for the `ended_at` field
+        pub struct ended_at(());
     }
 }
 
@@ -437,10 +437,10 @@ where
 impl<S: BosStr, St> ActivityBuilder<S, St>
 where
     St: activity_state::State,
-    St::EndedAt: activity_state::IsSet,
     St::Type: activity_state::IsSet,
     St::CreatedAt: activity_state::IsSet,
     St::StartedAt: activity_state::IsSet,
+    St::EndedAt: activity_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Activity<S> {
diff --git a/crates/jacquard-api/src/social_pace/goal/ring.rs b/crates/jacquard-api/src/social_pace/goal/ring.rs
index 2daf29a5..392b50ce 100644
--- a/crates/jacquard-api/src/social_pace/goal/ring.rs
+++ b/crates/jacquard-api/src/social_pace/goal/ring.rs
@@ -123,125 +123,125 @@ pub mod ring_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StandGoal;
-        type CreatedAt;
-        type Move;
-        type ExerciseGoal;
         type MoveGoal;
         type Exercise;
+        type ExerciseGoal;
+        type StandGoal;
+        type Move;
+        type CreatedAt;
         type StandHours;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StandGoal = Unset;
-        type CreatedAt = Unset;
-        type Move = Unset;
-        type ExerciseGoal = Unset;
         type MoveGoal = Unset;
         type Exercise = Unset;
+        type ExerciseGoal = Unset;
+        type StandGoal = Unset;
+        type Move = Unset;
+        type CreatedAt = Unset;
         type StandHours = Unset;
     }
-    ///State transition - sets the `stand_goal` field to Set
-    pub struct SetStandGoal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStandGoal<St> {}
-    impl<St: State> State for SetStandGoal<St> {
-        type StandGoal = Set<members::stand_goal>;
-        type CreatedAt = St::CreatedAt;
-        type Move = St::Move;
-        type ExerciseGoal = St::ExerciseGoal;
-        type MoveGoal = St::MoveGoal;
+    ///State transition - sets the `move_goal` field to Set
+    pub struct SetMoveGoal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMoveGoal<St> {}
+    impl<St: State> State for SetMoveGoal<St> {
+        type MoveGoal = Set<members::move_goal>;
         type Exercise = St::Exercise;
-        type StandHours = St::StandHours;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type ExerciseGoal = St::ExerciseGoal;
         type StandGoal = St::StandGoal;
-        type CreatedAt = Set<members::created_at>;
         type Move = St::Move;
-        type ExerciseGoal = St::ExerciseGoal;
-        type MoveGoal = St::MoveGoal;
-        type Exercise = St::Exercise;
+        type CreatedAt = St::CreatedAt;
         type StandHours = St::StandHours;
     }
-    ///State transition - sets the `move` field to Set
-    pub struct SetMove<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMove<St> {}
-    impl<St: State> State for SetMove<St> {
+    ///State transition - sets the `exercise` field to Set
+    pub struct SetExercise<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetExercise<St> {}
+    impl<St: State> State for SetExercise<St> {
+        type MoveGoal = St::MoveGoal;
+        type Exercise = Set<members::exercise>;
+        type ExerciseGoal = St::ExerciseGoal;
         type StandGoal = St::StandGoal;
+        type Move = St::Move;
         type CreatedAt = St::CreatedAt;
-        type Move = Set<members::r#move>;
-        type ExerciseGoal = St::ExerciseGoal;
-        type MoveGoal = St::MoveGoal;
-        type Exercise = St::Exercise;
         type StandHours = St::StandHours;
     }
     ///State transition - sets the `exercise_goal` field to Set
     pub struct SetExerciseGoal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetExerciseGoal<St> {}
     impl<St: State> State for SetExerciseGoal<St> {
+        type MoveGoal = St::MoveGoal;
+        type Exercise = St::Exercise;
+        type ExerciseGoal = Set<members::exercise_goal>;
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
         type Move = St::Move;
-        type ExerciseGoal = Set<members::exercise_goal>;
+        type CreatedAt = St::CreatedAt;
+        type StandHours = St::StandHours;
+    }
+    ///State transition - sets the `stand_goal` field to Set
+    pub struct SetStandGoal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStandGoal<St> {}
+    impl<St: State> State for SetStandGoal<St> {
         type MoveGoal = St::MoveGoal;
         type Exercise = St::Exercise;
+        type ExerciseGoal = St::ExerciseGoal;
+        type StandGoal = Set<members::stand_goal>;
+        type Move = St::Move;
+        type CreatedAt = St::CreatedAt;
         type StandHours = St::StandHours;
     }
-    ///State transition - sets the `move_goal` field to Set
-    pub struct SetMoveGoal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMoveGoal<St> {}
-    impl<St: State> State for SetMoveGoal<St> {
+    ///State transition - sets the `move` field to Set
+    pub struct SetMove<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMove<St> {}
+    impl<St: State> State for SetMove<St> {
+        type MoveGoal = St::MoveGoal;
+        type Exercise = St::Exercise;
+        type ExerciseGoal = St::ExerciseGoal;
         type StandGoal = St::StandGoal;
+        type Move = Set<members::r#move>;
         type CreatedAt = St::CreatedAt;
-        type Move = St::Move;
-        type ExerciseGoal = St::ExerciseGoal;
-        type MoveGoal = Set<members::move_goal>;
-        type Exercise = St::Exercise;
         type StandHours = St::StandHours;
     }
-    ///State transition - sets the `exercise` field to Set
-    pub struct SetExercise<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetExercise<St> {}
-    impl<St: State> State for SetExercise<St> {
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type MoveGoal = St::MoveGoal;
+        type Exercise = St::Exercise;
+        type ExerciseGoal = St::ExerciseGoal;
         type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
         type Move = St::Move;
-        type ExerciseGoal = St::ExerciseGoal;
-        type MoveGoal = St::MoveGoal;
-        type Exercise = Set<members::exercise>;
+        type CreatedAt = Set<members::created_at>;
         type StandHours = St::StandHours;
     }
     ///State transition - sets the `stand_hours` field to Set
     pub struct SetStandHours<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStandHours<St> {}
     impl<St: State> State for SetStandHours<St> {
-        type StandGoal = St::StandGoal;
-        type CreatedAt = St::CreatedAt;
-        type Move = St::Move;
-        type ExerciseGoal = St::ExerciseGoal;
         type MoveGoal = St::MoveGoal;
         type Exercise = St::Exercise;
+        type ExerciseGoal = St::ExerciseGoal;
+        type StandGoal = St::StandGoal;
+        type Move = St::Move;
+        type CreatedAt = St::CreatedAt;
         type StandHours = Set<members::stand_hours>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `stand_goal` field
-        pub struct stand_goal(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `move` field
-        pub struct r#move(());
-        ///Marker type for the `exercise_goal` field
-        pub struct exercise_goal(());
         ///Marker type for the `move_goal` field
         pub struct move_goal(());
         ///Marker type for the `exercise` field
         pub struct exercise(());
+        ///Marker type for the `exercise_goal` field
+        pub struct exercise_goal(());
+        ///Marker type for the `stand_goal` field
+        pub struct stand_goal(());
+        ///Marker type for the `move` field
+        pub struct r#move(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `stand_hours` field
         pub struct stand_hours(());
     }
@@ -416,12 +416,12 @@ where
 impl<S: BosStr, St> RingBuilder<S, St>
 where
     St: ring_state::State,
-    St::StandGoal: ring_state::IsSet,
-    St::CreatedAt: ring_state::IsSet,
-    St::Move: ring_state::IsSet,
-    St::ExerciseGoal: ring_state::IsSet,
     St::MoveGoal: ring_state::IsSet,
     St::Exercise: ring_state::IsSet,
+    St::ExerciseGoal: ring_state::IsSet,
+    St::StandGoal: ring_state::IsSet,
+    St::Move: ring_state::IsSet,
+    St::CreatedAt: ring_state::IsSet,
     St::StandHours: ring_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/social_pace/goal/step.rs b/crates/jacquard-api/src/social_pace/goal/step.rs
index f3768063..f91c018c 100644
--- a/crates/jacquard-api/src/social_pace/goal/step.rs
+++ b/crates/jacquard-api/src/social_pace/goal/step.rs
@@ -117,50 +117,50 @@ pub mod step_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Steps;
-        type CreatedAt;
         type UpdatedAt;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Steps = Unset;
-        type CreatedAt = Unset;
         type UpdatedAt = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `steps` field to Set
     pub struct SetSteps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSteps<St> {}
     impl<St: State> State for SetSteps<St> {
         type Steps = Set<members::steps>;
-        type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Steps = St::Steps;
-        type CreatedAt = Set<members::created_at>;
         type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `updated_at` field to Set
     pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
     impl<St: State> State for SetUpdatedAt<St> {
         type Steps = St::Steps;
-        type CreatedAt = St::CreatedAt;
         type UpdatedAt = Set<members::updated_at>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Steps = St::Steps;
+        type UpdatedAt = St::UpdatedAt;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `steps` field
         pub struct steps(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -250,8 +250,8 @@ impl<S: BosStr, St> StepBuilder<S, St>
 where
     St: step_state::State,
     St::Steps: step_state::IsSet,
-    St::CreatedAt: step_state::IsSet,
     St::UpdatedAt: step_state::IsSet,
+    St::CreatedAt: step_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Step<S> {
diff --git a/crates/jacquard-api/src/social_pmsky/proposal.rs b/crates/jacquard-api/src/social_pmsky/proposal.rs
index b787017a..66421cd1 100644
--- a/crates/jacquard-api/src/social_pmsky/proposal.rs
+++ b/crates/jacquard-api/src/social_pmsky/proposal.rs
@@ -150,85 +150,85 @@ pub mod proposal_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Val;
-        type Uri;
+        type Src;
         type Typ;
+        type Val;
         type Cts;
-        type Src;
+        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Val = Unset;
-        type Uri = Unset;
+        type Src = Unset;
         type Typ = Unset;
+        type Val = Unset;
         type Cts = Unset;
-        type Src = Unset;
+        type Uri = Unset;
     }
-    ///State transition - sets the `val` field to Set
-    pub struct SetVal<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVal<St> {}
-    impl<St: State> State for SetVal<St> {
-        type Val = Set<members::val>;
-        type Uri = St::Uri;
+    ///State transition - sets the `src` field to Set
+    pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSrc<St> {}
+    impl<St: State> State for SetSrc<St> {
+        type Src = Set<members::src>;
         type Typ = St::Typ;
-        type Cts = St::Cts;
-        type Src = St::Src;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Val = St::Val;
-        type Uri = Set<members::uri>;
-        type Typ = St::Typ;
         type Cts = St::Cts;
-        type Src = St::Src;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `typ` field to Set
     pub struct SetTyp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTyp<St> {}
     impl<St: State> State for SetTyp<St> {
-        type Val = St::Val;
-        type Uri = St::Uri;
+        type Src = St::Src;
         type Typ = Set<members::typ>;
+        type Val = St::Val;
         type Cts = St::Cts;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `val` field to Set
+    pub struct SetVal<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVal<St> {}
+    impl<St: State> State for SetVal<St> {
         type Src = St::Src;
+        type Typ = St::Typ;
+        type Val = Set<members::val>;
+        type Cts = St::Cts;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `cts` field to Set
     pub struct SetCts<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCts<St> {}
     impl<St: State> State for SetCts<St> {
-        type Val = St::Val;
-        type Uri = St::Uri;
-        type Typ = St::Typ;
-        type Cts = Set<members::cts>;
         type Src = St::Src;
-    }
-    ///State transition - sets the `src` field to Set
-    pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSrc<St> {}
-    impl<St: State> State for SetSrc<St> {
+        type Typ = St::Typ;
         type Val = St::Val;
+        type Cts = Set<members::cts>;
         type Uri = St::Uri;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Src = St::Src;
         type Typ = St::Typ;
+        type Val = St::Val;
         type Cts = St::Cts;
-        type Src = Set<members::src>;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `val` field
-        pub struct val(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
+        ///Marker type for the `src` field
+        pub struct src(());
         ///Marker type for the `typ` field
         pub struct typ(());
+        ///Marker type for the `val` field
+        pub struct val(());
         ///Marker type for the `cts` field
         pub struct cts(());
-        ///Marker type for the `src` field
-        pub struct src(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
     }
 }
 
@@ -445,11 +445,11 @@ impl<S: BosStr, St: proposal_state::State> ProposalBuilder<S, St> {
 impl<S: BosStr, St> ProposalBuilder<S, St>
 where
     St: proposal_state::State,
-    St::Val: proposal_state::IsSet,
-    St::Uri: proposal_state::IsSet,
+    St::Src: proposal_state::IsSet,
     St::Typ: proposal_state::IsSet,
+    St::Val: proposal_state::IsSet,
     St::Cts: proposal_state::IsSet,
-    St::Src: proposal_state::IsSet,
+    St::Uri: proposal_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Proposal<S> {
diff --git a/crates/jacquard-api/src/social_pmsky/vote.rs b/crates/jacquard-api/src/social_pmsky/vote.rs
index 7586db21..c0ea7803 100644
--- a/crates/jacquard-api/src/social_pmsky/vote.rs
+++ b/crates/jacquard-api/src/social_pmsky/vote.rs
@@ -131,67 +131,67 @@ pub mod vote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cts;
-        type Src;
         type Uri;
+        type Src;
         type Val;
+        type Cts;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cts = Unset;
-        type Src = Unset;
         type Uri = Unset;
+        type Src = Unset;
         type Val = Unset;
+        type Cts = Unset;
     }
-    ///State transition - sets the `cts` field to Set
-    pub struct SetCts<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCts<St> {}
-    impl<St: State> State for SetCts<St> {
-        type Cts = Set<members::cts>;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type Src = St::Src;
-        type Uri = St::Uri;
         type Val = St::Val;
+        type Cts = St::Cts;
     }
     ///State transition - sets the `src` field to Set
     pub struct SetSrc<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSrc<St> {}
     impl<St: State> State for SetSrc<St> {
-        type Cts = St::Cts;
-        type Src = Set<members::src>;
         type Uri = St::Uri;
+        type Src = Set<members::src>;
         type Val = St::Val;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
         type Cts = St::Cts;
-        type Src = St::Src;
-        type Uri = Set<members::uri>;
-        type Val = St::Val;
     }
     ///State transition - sets the `val` field to Set
     pub struct SetVal<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVal<St> {}
     impl<St: State> State for SetVal<St> {
-        type Cts = St::Cts;
-        type Src = St::Src;
         type Uri = St::Uri;
+        type Src = St::Src;
         type Val = Set<members::val>;
+        type Cts = St::Cts;
+    }
+    ///State transition - sets the `cts` field to Set
+    pub struct SetCts<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCts<St> {}
+    impl<St: State> State for SetCts<St> {
+        type Uri = St::Uri;
+        type Src = St::Src;
+        type Val = St::Val;
+        type Cts = Set<members::cts>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cts` field
-        pub struct cts(());
-        ///Marker type for the `src` field
-        pub struct src(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `src` field
+        pub struct src(());
         ///Marker type for the `val` field
         pub struct val(());
+        ///Marker type for the `cts` field
+        pub struct cts(());
     }
 }
 
@@ -360,10 +360,10 @@ where
 impl<S: BosStr, St> VoteBuilder<S, St>
 where
     St: vote_state::State,
-    St::Cts: vote_state::IsSet,
-    St::Src: vote_state::IsSet,
     St::Uri: vote_state::IsSet,
+    St::Src: vote_state::IsSet,
     St::Val: vote_state::IsSet,
+    St::Cts: vote_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Vote<S> {
diff --git a/crates/jacquard-api/src/social_psky/richtext/facet.rs b/crates/jacquard-api/src/social_psky/richtext/facet.rs
index b51c2135..ae08e664 100644
--- a/crates/jacquard-api/src/social_psky/richtext/facet.rs
+++ b/crates/jacquard-api/src/social_psky/richtext/facet.rs
@@ -219,37 +219,37 @@ pub mod byte_slice_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ByteEnd;
         type ByteStart;
+        type ByteEnd;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ByteEnd = Unset;
         type ByteStart = Unset;
-    }
-    ///State transition - sets the `byte_end` field to Set
-    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
-    impl<St: State> State for SetByteEnd<St> {
-        type ByteEnd = Set<members::byte_end>;
-        type ByteStart = St::ByteStart;
+        type ByteEnd = Unset;
     }
     ///State transition - sets the `byte_start` field to Set
     pub struct SetByteStart<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetByteStart<St> {}
     impl<St: State> State for SetByteStart<St> {
-        type ByteEnd = St::ByteEnd;
         type ByteStart = Set<members::byte_start>;
+        type ByteEnd = St::ByteEnd;
+    }
+    ///State transition - sets the `byte_end` field to Set
+    pub struct SetByteEnd<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetByteEnd<St> {}
+    impl<St: State> State for SetByteEnd<St> {
+        type ByteStart = St::ByteStart;
+        type ByteEnd = Set<members::byte_end>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `byte_end` field
-        pub struct byte_end(());
         ///Marker type for the `byte_start` field
         pub struct byte_start(());
+        ///Marker type for the `byte_end` field
+        pub struct byte_end(());
     }
 }
 
@@ -319,8 +319,8 @@ where
 impl<S: BosStr, St> ByteSliceBuilder<S, St>
 where
     St: byte_slice_state::State,
-    St::ByteEnd: byte_slice_state::IsSet,
     St::ByteStart: byte_slice_state::IsSet,
+    St::ByteEnd: byte_slice_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ByteSlice<S> {
diff --git a/crates/jacquard-api/src/social_showcase.rs b/crates/jacquard-api/src/social_showcase.rs
index 5f7bdae7..4938ac39 100644
--- a/crates/jacquard-api/src/social_showcase.rs
+++ b/crates/jacquard-api/src/social_showcase.rs
@@ -1289,50 +1289,50 @@ pub mod activity_settings_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type RetentionDays;
-        type ShareActivity;
         type ShareNewItems;
+        type ShareActivity;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type RetentionDays = Unset;
-        type ShareActivity = Unset;
         type ShareNewItems = Unset;
+        type ShareActivity = Unset;
     }
     ///State transition - sets the `retention_days` field to Set
     pub struct SetRetentionDays<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRetentionDays<St> {}
     impl<St: State> State for SetRetentionDays<St> {
         type RetentionDays = Set<members::retention_days>;
-        type ShareActivity = St::ShareActivity;
-        type ShareNewItems = St::ShareNewItems;
-    }
-    ///State transition - sets the `share_activity` field to Set
-    pub struct SetShareActivity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetShareActivity<St> {}
-    impl<St: State> State for SetShareActivity<St> {
-        type RetentionDays = St::RetentionDays;
-        type ShareActivity = Set<members::share_activity>;
         type ShareNewItems = St::ShareNewItems;
+        type ShareActivity = St::ShareActivity;
     }
     ///State transition - sets the `share_new_items` field to Set
     pub struct SetShareNewItems<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetShareNewItems<St> {}
     impl<St: State> State for SetShareNewItems<St> {
         type RetentionDays = St::RetentionDays;
-        type ShareActivity = St::ShareActivity;
         type ShareNewItems = Set<members::share_new_items>;
+        type ShareActivity = St::ShareActivity;
+    }
+    ///State transition - sets the `share_activity` field to Set
+    pub struct SetShareActivity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetShareActivity<St> {}
+    impl<St: State> State for SetShareActivity<St> {
+        type RetentionDays = St::RetentionDays;
+        type ShareNewItems = St::ShareNewItems;
+        type ShareActivity = Set<members::share_activity>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `retention_days` field
         pub struct retention_days(());
-        ///Marker type for the `share_activity` field
-        pub struct share_activity(());
         ///Marker type for the `share_new_items` field
         pub struct share_new_items(());
+        ///Marker type for the `share_activity` field
+        pub struct share_activity(());
     }
 }
 
@@ -1422,8 +1422,8 @@ impl<S: BosStr, St> ActivitySettingsBuilder<S, St>
 where
     St: activity_settings_state::State,
     St::RetentionDays: activity_settings_state::IsSet,
-    St::ShareActivity: activity_settings_state::IsSet,
     St::ShareNewItems: activity_settings_state::IsSet,
+    St::ShareActivity: activity_settings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ActivitySettings<S> {
@@ -2193,51 +2193,51 @@ pub mod collection_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Order;
         type Uri;
         type AddedAt;
+        type Order;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Order = Unset;
         type Uri = Unset;
         type AddedAt = Unset;
-    }
-    ///State transition - sets the `order` field to Set
-    pub struct SetOrder<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOrder<St> {}
-    impl<St: State> State for SetOrder<St> {
-        type Order = Set<members::order>;
-        type Uri = St::Uri;
-        type AddedAt = St::AddedAt;
+        type Order = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Order = St::Order;
         type Uri = Set<members::uri>;
         type AddedAt = St::AddedAt;
+        type Order = St::Order;
     }
     ///State transition - sets the `added_at` field to Set
     pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAddedAt<St> {}
     impl<St: State> State for SetAddedAt<St> {
-        type Order = St::Order;
         type Uri = St::Uri;
         type AddedAt = Set<members::added_at>;
+        type Order = St::Order;
+    }
+    ///State transition - sets the `order` field to Set
+    pub struct SetOrder<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOrder<St> {}
+    impl<St: State> State for SetOrder<St> {
+        type Uri = St::Uri;
+        type AddedAt = St::AddedAt;
+        type Order = Set<members::order>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `order` field
-        pub struct order(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `added_at` field
         pub struct added_at(());
+        ///Marker type for the `order` field
+        pub struct order(());
     }
 }
 
@@ -2326,9 +2326,9 @@ where
 impl<S: BosStr, St> CollectionItemBuilder<S, St>
 where
     St: collection_item_state::State,
-    St::Order: collection_item_state::IsSet,
     St::Uri: collection_item_state::IsSet,
     St::AddedAt: collection_item_state::IsSet,
+    St::Order: collection_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CollectionItem<S> {
@@ -2363,139 +2363,137 @@ pub mod collection_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type Cid;
+        type Visibility;
         type Tags;
         type Type;
         type CreatedAt;
         type Uri;
-        type Visibility;
+        type Name;
+        type Cid;
         type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type Cid = Unset;
+        type Visibility = Unset;
         type Tags = Unset;
         type Type = Unset;
         type CreatedAt = Unset;
         type Uri = Unset;
-        type Visibility = Unset;
+        type Name = Unset;
+        type Cid = Unset;
         type Author = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Cid = St::Cid;
+    ///State transition - sets the `visibility` field to Set
+    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVisibility<St> {}
+    impl<St: State> State for SetVisibility<St> {
+        type Visibility = Set<members::visibility>;
         type Tags = St::Tags;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type Visibility = St::Visibility;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
         type Name = St::Name;
-        type Cid = Set<members::cid>;
-        type Tags = St::Tags;
-        type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
-        type Visibility = St::Visibility;
+        type Cid = St::Cid;
         type Author = St::Author;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
-        type Name = St::Name;
-        type Cid = St::Cid;
+        type Visibility = St::Visibility;
         type Tags = Set<members::tags>;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type Visibility = St::Visibility;
+        type Name = St::Name;
+        type Cid = St::Cid;
         type Author = St::Author;
     }
     ///State transition - sets the `type` field to Set
     pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetType<St> {}
     impl<St: State> State for SetType<St> {
-        type Name = St::Name;
-        type Cid = St::Cid;
+        type Visibility = St::Visibility;
         type Tags = St::Tags;
         type Type = Set<members::r#type>;
         type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type Visibility = St::Visibility;
+        type Name = St::Name;
+        type Cid = St::Cid;
         type Author = St::Author;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
-        type Cid = St::Cid;
+        type Visibility = St::Visibility;
         type Tags = St::Tags;
         type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-        type Visibility = St::Visibility;
+        type Name = St::Name;
+        type Cid = St::Cid;
         type Author = St::Author;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Name = St::Name;
-        type Cid = St::Cid;
+        type Visibility = St::Visibility;
         type Tags = St::Tags;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type Uri = Set<members::uri>;
-        type Visibility = St::Visibility;
+        type Name = St::Name;
+        type Cid = St::Cid;
         type Author = St::Author;
     }
-    ///State transition - sets the `visibility` field to Set
-    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVisibility<St> {}
-    impl<St: State> State for SetVisibility<St> {
-        type Name = St::Name;
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Visibility = St::Visibility;
+        type Tags = St::Tags;
+        type Type = St::Type;
+        type CreatedAt = St::CreatedAt;
+        type Uri = St::Uri;
+        type Name = Set<members::name>;
         type Cid = St::Cid;
+        type Author = St::Author;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Visibility = St::Visibility;
         type Tags = St::Tags;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type Visibility = Set<members::visibility>;
+        type Name = St::Name;
+        type Cid = Set<members::cid>;
         type Author = St::Author;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Name = St::Name;
-        type Cid = St::Cid;
+        type Visibility = St::Visibility;
         type Tags = St::Tags;
         type Type = St::Type;
         type CreatedAt = St::CreatedAt;
         type Uri = St::Uri;
-        type Visibility = St::Visibility;
+        type Name = St::Name;
+        type Cid = St::Cid;
         type Author = Set<members::author>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
+        ///Marker type for the `visibility` field
+        pub struct visibility(());
         ///Marker type for the `tags` field
         pub struct tags(());
         ///Marker type for the `type` field
@@ -2504,8 +2502,10 @@ pub mod collection_view_state {
         pub struct created_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `visibility` field
-        pub struct visibility(());
+        ///Marker type for the `name` field
+        pub struct name(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `author` field
         pub struct author(());
     }
@@ -2790,13 +2790,13 @@ where
 impl<S: BosStr, St> CollectionViewBuilder<S, St>
 where
     St: collection_view_state::State,
-    St::Name: collection_view_state::IsSet,
-    St::Cid: collection_view_state::IsSet,
+    St::Visibility: collection_view_state::IsSet,
     St::Tags: collection_view_state::IsSet,
     St::Type: collection_view_state::IsSet,
     St::CreatedAt: collection_view_state::IsSet,
     St::Uri: collection_view_state::IsSet,
-    St::Visibility: collection_view_state::IsSet,
+    St::Name: collection_view_state::IsSet,
+    St::Cid: collection_view_state::IsSet,
     St::Author: collection_view_state::IsSet,
 {
     /// Build the final struct.
@@ -2988,151 +2988,151 @@ pub mod item_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Visibility;
+        type Author;
+        type Uri;
+        type Title;
+        type Images;
         type Tags;
         type Cid;
-        type Title;
-        type Uri;
-        type Author;
         type CreatedAt;
-        type Visibility;
-        type Images;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Visibility = Unset;
+        type Author = Unset;
+        type Uri = Unset;
+        type Title = Unset;
+        type Images = Unset;
         type Tags = Unset;
         type Cid = Unset;
-        type Title = Unset;
-        type Uri = Unset;
-        type Author = Unset;
         type CreatedAt = Unset;
-        type Visibility = Unset;
-        type Images = Unset;
     }
-    ///State transition - sets the `tags` field to Set
-    pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTags<St> {}
-    impl<St: State> State for SetTags<St> {
-        type Tags = Set<members::tags>;
-        type Cid = St::Cid;
-        type Title = St::Title;
-        type Uri = St::Uri;
+    ///State transition - sets the `visibility` field to Set
+    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVisibility<St> {}
+    impl<St: State> State for SetVisibility<St> {
+        type Visibility = Set<members::visibility>;
         type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
-        type Visibility = St::Visibility;
+        type Uri = St::Uri;
+        type Title = St::Title;
         type Images = St::Images;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
         type Tags = St::Tags;
-        type Cid = Set<members::cid>;
-        type Title = St::Title;
-        type Uri = St::Uri;
-        type Author = St::Author;
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
         type Visibility = St::Visibility;
+        type Author = Set<members::author>;
+        type Uri = St::Uri;
+        type Title = St::Title;
         type Images = St::Images;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
         type Tags = St::Tags;
         type Cid = St::Cid;
-        type Title = Set<members::title>;
-        type Uri = St::Uri;
-        type Author = St::Author;
         type CreatedAt = St::CreatedAt;
-        type Visibility = St::Visibility;
-        type Images = St::Images;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
+        type Visibility = St::Visibility;
+        type Author = St::Author;
+        type Uri = Set<members::uri>;
+        type Title = St::Title;
+        type Images = St::Images;
         type Tags = St::Tags;
         type Cid = St::Cid;
-        type Title = St::Title;
-        type Uri = Set<members::uri>;
-        type Author = St::Author;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
         type Visibility = St::Visibility;
+        type Author = St::Author;
+        type Uri = St::Uri;
+        type Title = Set<members::title>;
         type Images = St::Images;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
         type Tags = St::Tags;
         type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `images` field to Set
+    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImages<St> {}
+    impl<St: State> State for SetImages<St> {
+        type Visibility = St::Visibility;
+        type Author = St::Author;
+        type Uri = St::Uri;
         type Title = St::Title;
+        type Images = Set<members::images>;
+        type Tags = St::Tags;
+        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `tags` field to Set
+    pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTags<St> {}
+    impl<St: State> State for SetTags<St> {
+        type Visibility = St::Visibility;
+        type Author = St::Author;
         type Uri = St::Uri;
-        type Author = Set<members::author>;
+        type Title = St::Title;
+        type Images = St::Images;
+        type Tags = Set<members::tags>;
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
         type Visibility = St::Visibility;
+        type Author = St::Author;
+        type Uri = St::Uri;
+        type Title = St::Title;
         type Images = St::Images;
+        type Tags = St::Tags;
+        type Cid = Set<members::cid>;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Tags = St::Tags;
-        type Cid = St::Cid;
-        type Title = St::Title;
-        type Uri = St::Uri;
-        type Author = St::Author;
-        type CreatedAt = Set<members::created_at>;
         type Visibility = St::Visibility;
-        type Images = St::Images;
-    }
-    ///State transition - sets the `visibility` field to Set
-    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVisibility<St> {}
-    impl<St: State> State for SetVisibility<St> {
-        type Tags = St::Tags;
-        type Cid = St::Cid;
-        type Title = St::Title;
-        type Uri = St::Uri;
         type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
-        type Visibility = Set<members::visibility>;
+        type Uri = St::Uri;
+        type Title = St::Title;
         type Images = St::Images;
-    }
-    ///State transition - sets the `images` field to Set
-    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImages<St> {}
-    impl<St: State> State for SetImages<St> {
         type Tags = St::Tags;
         type Cid = St::Cid;
-        type Title = St::Title;
-        type Uri = St::Uri;
-        type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
-        type Visibility = St::Visibility;
-        type Images = Set<members::images>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `visibility` field
+        pub struct visibility(());
+        ///Marker type for the `author` field
+        pub struct author(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `title` field
+        pub struct title(());
+        ///Marker type for the `images` field
+        pub struct images(());
         ///Marker type for the `tags` field
         pub struct tags(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `visibility` field
-        pub struct visibility(());
-        ///Marker type for the `images` field
-        pub struct images(());
     }
 }
 
@@ -3424,14 +3424,14 @@ where
 impl<S: BosStr, St> ItemViewBuilder<S, St>
 where
     St: item_view_state::State,
+    St::Visibility: item_view_state::IsSet,
+    St::Author: item_view_state::IsSet,
+    St::Uri: item_view_state::IsSet,
+    St::Title: item_view_state::IsSet,
+    St::Images: item_view_state::IsSet,
     St::Tags: item_view_state::IsSet,
     St::Cid: item_view_state::IsSet,
-    St::Title: item_view_state::IsSet,
-    St::Uri: item_view_state::IsSet,
-    St::Author: item_view_state::IsSet,
     St::CreatedAt: item_view_state::IsSet,
-    St::Visibility: item_view_state::IsSet,
-    St::Images: item_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ItemView<S> {
@@ -3486,50 +3486,50 @@ pub mod notification_settings_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Reactions;
-        type Follows;
         type Comments;
+        type Follows;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Reactions = Unset;
-        type Follows = Unset;
         type Comments = Unset;
+        type Follows = Unset;
     }
     ///State transition - sets the `reactions` field to Set
     pub struct SetReactions<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReactions<St> {}
     impl<St: State> State for SetReactions<St> {
         type Reactions = Set<members::reactions>;
-        type Follows = St::Follows;
-        type Comments = St::Comments;
-    }
-    ///State transition - sets the `follows` field to Set
-    pub struct SetFollows<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetFollows<St> {}
-    impl<St: State> State for SetFollows<St> {
-        type Reactions = St::Reactions;
-        type Follows = Set<members::follows>;
         type Comments = St::Comments;
+        type Follows = St::Follows;
     }
     ///State transition - sets the `comments` field to Set
     pub struct SetComments<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetComments<St> {}
     impl<St: State> State for SetComments<St> {
         type Reactions = St::Reactions;
-        type Follows = St::Follows;
         type Comments = Set<members::comments>;
+        type Follows = St::Follows;
+    }
+    ///State transition - sets the `follows` field to Set
+    pub struct SetFollows<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetFollows<St> {}
+    impl<St: State> State for SetFollows<St> {
+        type Reactions = St::Reactions;
+        type Comments = St::Comments;
+        type Follows = Set<members::follows>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `reactions` field
         pub struct reactions(());
-        ///Marker type for the `follows` field
-        pub struct follows(());
         ///Marker type for the `comments` field
         pub struct comments(());
+        ///Marker type for the `follows` field
+        pub struct follows(());
     }
 }
 
@@ -3622,8 +3622,8 @@ impl<S: BosStr, St> NotificationSettingsBuilder<S, St>
 where
     St: notification_settings_state::State,
     St::Reactions: notification_settings_state::IsSet,
-    St::Follows: notification_settings_state::IsSet,
     St::Comments: notification_settings_state::IsSet,
+    St::Follows: notification_settings_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NotificationSettings<S> {
@@ -3658,49 +3658,49 @@ pub mod privacy_settings_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AllowReactions;
         type Indexable;
+        type AllowReactions;
         type AllowComments;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AllowReactions = Unset;
         type Indexable = Unset;
+        type AllowReactions = Unset;
         type AllowComments = Unset;
     }
-    ///State transition - sets the `allow_reactions` field to Set
-    pub struct SetAllowReactions<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAllowReactions<St> {}
-    impl<St: State> State for SetAllowReactions<St> {
-        type AllowReactions = Set<members::allow_reactions>;
-        type Indexable = St::Indexable;
-        type AllowComments = St::AllowComments;
-    }
     ///State transition - sets the `indexable` field to Set
     pub struct SetIndexable<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexable<St> {}
     impl<St: State> State for SetIndexable<St> {
-        type AllowReactions = St::AllowReactions;
         type Indexable = Set<members::indexable>;
+        type AllowReactions = St::AllowReactions;
+        type AllowComments = St::AllowComments;
+    }
+    ///State transition - sets the `allow_reactions` field to Set
+    pub struct SetAllowReactions<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAllowReactions<St> {}
+    impl<St: State> State for SetAllowReactions<St> {
+        type Indexable = St::Indexable;
+        type AllowReactions = Set<members::allow_reactions>;
         type AllowComments = St::AllowComments;
     }
     ///State transition - sets the `allow_comments` field to Set
     pub struct SetAllowComments<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAllowComments<St> {}
     impl<St: State> State for SetAllowComments<St> {
-        type AllowReactions = St::AllowReactions;
         type Indexable = St::Indexable;
+        type AllowReactions = St::AllowReactions;
         type AllowComments = Set<members::allow_comments>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `allow_reactions` field
-        pub struct allow_reactions(());
         ///Marker type for the `indexable` field
         pub struct indexable(());
+        ///Marker type for the `allow_reactions` field
+        pub struct allow_reactions(());
         ///Marker type for the `allow_comments` field
         pub struct allow_comments(());
     }
@@ -3791,8 +3791,8 @@ where
 impl<S: BosStr, St> PrivacySettingsBuilder<S, St>
 where
     St: privacy_settings_state::State,
-    St::AllowReactions: privacy_settings_state::IsSet,
     St::Indexable: privacy_settings_state::IsSet,
+    St::AllowReactions: privacy_settings_state::IsSet,
     St::AllowComments: privacy_settings_state::IsSet,
 {
     /// Build the final struct.
@@ -3962,85 +3962,85 @@ pub mod reaction_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type CreatedAt;
-        type Subject;
-        type Uri;
         type Actor;
+        type Type;
+        type Uri;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type CreatedAt = Unset;
-        type Subject = Unset;
-        type Uri = Unset;
         type Actor = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-        type Uri = St::Uri;
-        type Actor = St::Actor;
+        type Type = Unset;
+        type Uri = Unset;
+        type Subject = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
-        type Uri = St::Uri;
         type Actor = St::Actor;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
         type Type = St::Type;
+        type Uri = St::Uri;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `actor` field to Set
+    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActor<St> {}
+    impl<St: State> State for SetActor<St> {
         type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
+        type Actor = Set<members::actor>;
+        type Type = St::Type;
         type Uri = St::Uri;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type CreatedAt = St::CreatedAt;
         type Actor = St::Actor;
+        type Type = Set<members::r#type>;
+        type Uri = St::Uri;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Type = St::Type;
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-        type Uri = Set<members::uri>;
         type Actor = St::Actor;
-    }
-    ///State transition - sets the `actor` field to Set
-    pub struct SetActor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActor<St> {}
-    impl<St: State> State for SetActor<St> {
         type Type = St::Type;
-        type CreatedAt = St::CreatedAt;
+        type Uri = Set<members::uri>;
         type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type CreatedAt = St::CreatedAt;
+        type Actor = St::Actor;
+        type Type = St::Type;
         type Uri = St::Uri;
-        type Actor = Set<members::actor>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `actor` field
         pub struct actor(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -4173,11 +4173,11 @@ where
 impl<S: BosStr, St> ReactionViewBuilder<S, St>
 where
     St: reaction_view_state::State,
-    St::Type: reaction_view_state::IsSet,
     St::CreatedAt: reaction_view_state::IsSet,
-    St::Subject: reaction_view_state::IsSet,
-    St::Uri: reaction_view_state::IsSet,
     St::Actor: reaction_view_state::IsSet,
+    St::Type: reaction_view_state::IsSet,
+    St::Uri: reaction_view_state::IsSet,
+    St::Subject: reaction_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReactionView<S> {
@@ -4216,51 +4216,51 @@ pub mod showcase_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type AddedAt;
         type Order;
         type Uri;
+        type AddedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type AddedAt = Unset;
         type Order = Unset;
         type Uri = Unset;
-    }
-    ///State transition - sets the `added_at` field to Set
-    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
-    impl<St: State> State for SetAddedAt<St> {
-        type AddedAt = Set<members::added_at>;
-        type Order = St::Order;
-        type Uri = St::Uri;
+        type AddedAt = Unset;
     }
     ///State transition - sets the `order` field to Set
     pub struct SetOrder<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOrder<St> {}
     impl<St: State> State for SetOrder<St> {
-        type AddedAt = St::AddedAt;
         type Order = Set<members::order>;
         type Uri = St::Uri;
+        type AddedAt = St::AddedAt;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type AddedAt = St::AddedAt;
         type Order = St::Order;
         type Uri = Set<members::uri>;
+        type AddedAt = St::AddedAt;
+    }
+    ///State transition - sets the `added_at` field to Set
+    pub struct SetAddedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAddedAt<St> {}
+    impl<St: State> State for SetAddedAt<St> {
+        type Order = St::Order;
+        type Uri = St::Uri;
+        type AddedAt = Set<members::added_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `added_at` field
-        pub struct added_at(());
         ///Marker type for the `order` field
         pub struct order(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `added_at` field
+        pub struct added_at(());
     }
 }
 
@@ -4349,9 +4349,9 @@ where
 impl<S: BosStr, St> ShowcaseItemBuilder<S, St>
 where
     St: showcase_item_state::State,
-    St::AddedAt: showcase_item_state::IsSet,
     St::Order: showcase_item_state::IsSet,
     St::Uri: showcase_item_state::IsSet,
+    St::AddedAt: showcase_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ShowcaseItem<S> {
diff --git a/crates/jacquard-api/src/social_showcase/graph/block.rs b/crates/jacquard-api/src/social_showcase/graph/block.rs
index fece78c8..87ccd620 100644
--- a/crates/jacquard-api/src/social_showcase/graph/block.rs
+++ b/crates/jacquard-api/src/social_showcase/graph/block.rs
@@ -113,37 +113,37 @@ pub mod block_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Subject;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Subject = St::Subject;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
         type Subject = Set<members::subject>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -213,8 +213,8 @@ where
 impl<S: BosStr, St> BlockBuilder<S, St>
 where
     St: block_state::State,
-    St::CreatedAt: block_state::IsSet,
     St::Subject: block_state::IsSet,
+    St::CreatedAt: block_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Block<S> {
diff --git a/crates/jacquard-api/src/social_showcase/library/create_item.rs b/crates/jacquard-api/src/social_showcase/library/create_item.rs
index c2f62891..852318ce 100644
--- a/crates/jacquard-api/src/social_showcase/library/create_item.rs
+++ b/crates/jacquard-api/src/social_showcase/library/create_item.rs
@@ -170,67 +170,67 @@ pub mod create_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Images;
+        type Visibility;
         type Tags;
         type Title;
-        type Visibility;
-        type Images;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Images = Unset;
+        type Visibility = Unset;
         type Tags = Unset;
         type Title = Unset;
-        type Visibility = Unset;
-        type Images = Unset;
+    }
+    ///State transition - sets the `images` field to Set
+    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImages<St> {}
+    impl<St: State> State for SetImages<St> {
+        type Images = Set<members::images>;
+        type Visibility = St::Visibility;
+        type Tags = St::Tags;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `visibility` field to Set
+    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetVisibility<St> {}
+    impl<St: State> State for SetVisibility<St> {
+        type Images = St::Images;
+        type Visibility = Set<members::visibility>;
+        type Tags = St::Tags;
+        type Title = St::Title;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
+        type Images = St::Images;
+        type Visibility = St::Visibility;
         type Tags = Set<members::tags>;
         type Title = St::Title;
-        type Visibility = St::Visibility;
-        type Images = St::Images;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type Tags = St::Tags;
-        type Title = Set<members::title>;
-        type Visibility = St::Visibility;
-        type Images = St::Images;
-    }
-    ///State transition - sets the `visibility` field to Set
-    pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetVisibility<St> {}
-    impl<St: State> State for SetVisibility<St> {
-        type Tags = St::Tags;
-        type Title = St::Title;
-        type Visibility = Set<members::visibility>;
         type Images = St::Images;
-    }
-    ///State transition - sets the `images` field to Set
-    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImages<St> {}
-    impl<St: State> State for SetImages<St> {
-        type Tags = St::Tags;
-        type Title = St::Title;
         type Visibility = St::Visibility;
-        type Images = Set<members::images>;
+        type Tags = St::Tags;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `images` field
+        pub struct images(());
+        ///Marker type for the `visibility` field
+        pub struct visibility(());
         ///Marker type for the `tags` field
         pub struct tags(());
         ///Marker type for the `title` field
         pub struct title(());
-        ///Marker type for the `visibility` field
-        pub struct visibility(());
-        ///Marker type for the `images` field
-        pub struct images(());
     }
 }
 
@@ -399,10 +399,10 @@ where
 impl<S: BosStr, St> CreateItemBuilder<S, St>
 where
     St: create_item_state::State,
+    St::Images: create_item_state::IsSet,
+    St::Visibility: create_item_state::IsSet,
     St::Tags: create_item_state::IsSet,
     St::Title: create_item_state::IsSet,
-    St::Visibility: create_item_state::IsSet,
-    St::Images: create_item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> CreateItem<S> {
diff --git a/crates/jacquard-api/src/social_showcase/library/item.rs b/crates/jacquard-api/src/social_showcase/library/item.rs
index 8d2d1fec..0513cbe5 100644
--- a/crates/jacquard-api/src/social_showcase/library/item.rs
+++ b/crates/jacquard-api/src/social_showcase/library/item.rs
@@ -300,85 +300,85 @@ pub mod item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
-        type Images;
         type Tags;
         type Visibility;
+        type Images;
         type CreatedAt;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
-        type Images = Unset;
         type Tags = Unset;
         type Visibility = Unset;
+        type Images = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Images = St::Images;
-        type Tags = St::Tags;
-        type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `images` field to Set
-    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImages<St> {}
-    impl<St: State> State for SetImages<St> {
-        type Title = St::Title;
-        type Images = Set<members::images>;
-        type Tags = St::Tags;
-        type Visibility = St::Visibility;
-        type CreatedAt = St::CreatedAt;
+        type Title = Unset;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
-        type Title = St::Title;
-        type Images = St::Images;
         type Tags = Set<members::tags>;
         type Visibility = St::Visibility;
+        type Images = St::Images;
         type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
     }
     ///State transition - sets the `visibility` field to Set
     pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVisibility<St> {}
     impl<St: State> State for SetVisibility<St> {
-        type Title = St::Title;
-        type Images = St::Images;
         type Tags = St::Tags;
         type Visibility = Set<members::visibility>;
+        type Images = St::Images;
+        type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `images` field to Set
+    pub struct SetImages<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImages<St> {}
+    impl<St: State> State for SetImages<St> {
+        type Tags = St::Tags;
+        type Visibility = St::Visibility;
+        type Images = Set<members::images>;
         type CreatedAt = St::CreatedAt;
+        type Title = St::Title;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Title = St::Title;
-        type Images = St::Images;
         type Tags = St::Tags;
         type Visibility = St::Visibility;
+        type Images = St::Images;
         type CreatedAt = Set<members::created_at>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Tags = St::Tags;
+        type Visibility = St::Visibility;
+        type Images = St::Images;
+        type CreatedAt = St::CreatedAt;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
-        ///Marker type for the `images` field
-        pub struct images(());
         ///Marker type for the `tags` field
         pub struct tags(());
         ///Marker type for the `visibility` field
         pub struct visibility(());
+        ///Marker type for the `images` field
+        pub struct images(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -622,11 +622,11 @@ where
 impl<S: BosStr, St> ItemBuilder<S, St>
 where
     St: item_state::State,
-    St::Title: item_state::IsSet,
-    St::Images: item_state::IsSet,
     St::Tags: item_state::IsSet,
     St::Visibility: item_state::IsSet,
+    St::Images: item_state::IsSet,
     St::CreatedAt: item_state::IsSet,
+    St::Title: item_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Item<S> {
diff --git a/crates/jacquard-api/src/social_showcase/profile/preferences.rs b/crates/jacquard-api/src/social_showcase/profile/preferences.rs
index 97c4a60b..7835f016 100644
--- a/crates/jacquard-api/src/social_showcase/profile/preferences.rs
+++ b/crates/jacquard-api/src/social_showcase/profile/preferences.rs
@@ -130,85 +130,85 @@ pub mod preferences_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Activity;
-        type UpdatedAt;
         type Privacy;
         type Notifications;
         type Visibility;
+        type Activity;
+        type UpdatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Activity = Unset;
-        type UpdatedAt = Unset;
         type Privacy = Unset;
         type Notifications = Unset;
         type Visibility = Unset;
-    }
-    ///State transition - sets the `activity` field to Set
-    pub struct SetActivity<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetActivity<St> {}
-    impl<St: State> State for SetActivity<St> {
-        type Activity = Set<members::activity>;
-        type UpdatedAt = St::UpdatedAt;
-        type Privacy = St::Privacy;
-        type Notifications = St::Notifications;
-        type Visibility = St::Visibility;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type Activity = St::Activity;
-        type UpdatedAt = Set<members::updated_at>;
-        type Privacy = St::Privacy;
-        type Notifications = St::Notifications;
-        type Visibility = St::Visibility;
+        type Activity = Unset;
+        type UpdatedAt = Unset;
     }
     ///State transition - sets the `privacy` field to Set
     pub struct SetPrivacy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPrivacy<St> {}
     impl<St: State> State for SetPrivacy<St> {
-        type Activity = St::Activity;
-        type UpdatedAt = St::UpdatedAt;
         type Privacy = Set<members::privacy>;
         type Notifications = St::Notifications;
         type Visibility = St::Visibility;
+        type Activity = St::Activity;
+        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `notifications` field to Set
     pub struct SetNotifications<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNotifications<St> {}
     impl<St: State> State for SetNotifications<St> {
-        type Activity = St::Activity;
-        type UpdatedAt = St::UpdatedAt;
         type Privacy = St::Privacy;
         type Notifications = Set<members::notifications>;
         type Visibility = St::Visibility;
+        type Activity = St::Activity;
+        type UpdatedAt = St::UpdatedAt;
     }
     ///State transition - sets the `visibility` field to Set
     pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVisibility<St> {}
     impl<St: State> State for SetVisibility<St> {
+        type Privacy = St::Privacy;
+        type Notifications = St::Notifications;
+        type Visibility = Set<members::visibility>;
         type Activity = St::Activity;
         type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `activity` field to Set
+    pub struct SetActivity<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetActivity<St> {}
+    impl<St: State> State for SetActivity<St> {
         type Privacy = St::Privacy;
         type Notifications = St::Notifications;
-        type Visibility = Set<members::visibility>;
+        type Visibility = St::Visibility;
+        type Activity = Set<members::activity>;
+        type UpdatedAt = St::UpdatedAt;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type Privacy = St::Privacy;
+        type Notifications = St::Notifications;
+        type Visibility = St::Visibility;
+        type Activity = St::Activity;
+        type UpdatedAt = Set<members::updated_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `activity` field
-        pub struct activity(());
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `privacy` field
         pub struct privacy(());
         ///Marker type for the `notifications` field
         pub struct notifications(());
         ///Marker type for the `visibility` field
         pub struct visibility(());
+        ///Marker type for the `activity` field
+        pub struct activity(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
     }
 }
 
@@ -369,11 +369,11 @@ where
 impl<S: BosStr, St> PreferencesBuilder<S, St>
 where
     St: preferences_state::State,
-    St::Activity: preferences_state::IsSet,
-    St::UpdatedAt: preferences_state::IsSet,
     St::Privacy: preferences_state::IsSet,
     St::Notifications: preferences_state::IsSet,
     St::Visibility: preferences_state::IsSet,
+    St::Activity: preferences_state::IsSet,
+    St::UpdatedAt: preferences_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Preferences<S> {
diff --git a/crates/jacquard-api/src/social_showcase/profile/profile.rs b/crates/jacquard-api/src/social_showcase/profile/profile.rs
index 226aee00..cb0a1318 100644
--- a/crates/jacquard-api/src/social_showcase/profile/profile.rs
+++ b/crates/jacquard-api/src/social_showcase/profile/profile.rs
@@ -344,67 +344,67 @@ pub mod profile_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
+        type CreatedAt;
         type Handle;
         type Tags;
-        type CreatedAt;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
+        type CreatedAt = Unset;
         type Handle = Unset;
         type Tags = Unset;
-        type CreatedAt = Unset;
+        type Did = Unset;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type Handle = St::Handle;
         type Tags = St::Tags;
-        type CreatedAt = St::CreatedAt;
+        type Did = St::Did;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
         type Handle = Set<members::handle>;
         type Tags = St::Tags;
-        type CreatedAt = St::CreatedAt;
+        type Did = St::Did;
     }
     ///State transition - sets the `tags` field to Set
     pub struct SetTags<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTags<St> {}
     impl<St: State> State for SetTags<St> {
-        type Did = St::Did;
+        type CreatedAt = St::CreatedAt;
         type Handle = St::Handle;
         type Tags = Set<members::tags>;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type CreatedAt = St::CreatedAt;
         type Handle = St::Handle;
         type Tags = St::Tags;
-        type CreatedAt = Set<members::created_at>;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `handle` field
         pub struct handle(());
         ///Marker type for the `tags` field
         pub struct tags(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -702,10 +702,10 @@ impl<S: BosStr, St: profile_state::State> ProfileBuilder<S, St> {
 impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
-    St::Did: profile_state::IsSet,
+    St::CreatedAt: profile_state::IsSet,
     St::Handle: profile_state::IsSet,
     St::Tags: profile_state::IsSet,
-    St::CreatedAt: profile_state::IsSet,
+    St::Did: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
diff --git a/crates/jacquard-api/src/social_tophhie/profile.rs b/crates/jacquard-api/src/social_tophhie/profile.rs
index 7db84536..f1d6bcb6 100644
--- a/crates/jacquard-api/src/social_tophhie/profile.rs
+++ b/crates/jacquard-api/src/social_tophhie/profile.rs
@@ -415,50 +415,50 @@ pub mod profile_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type PdsPreferences;
-        type CommunicationPreferences;
         type CreatedAt;
+        type CommunicationPreferences;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type PdsPreferences = Unset;
-        type CommunicationPreferences = Unset;
         type CreatedAt = Unset;
+        type CommunicationPreferences = Unset;
     }
     ///State transition - sets the `pds_preferences` field to Set
     pub struct SetPdsPreferences<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPdsPreferences<St> {}
     impl<St: State> State for SetPdsPreferences<St> {
         type PdsPreferences = Set<members::pds_preferences>;
-        type CommunicationPreferences = St::CommunicationPreferences;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `communication_preferences` field to Set
-    pub struct SetCommunicationPreferences<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCommunicationPreferences<St> {}
-    impl<St: State> State for SetCommunicationPreferences<St> {
-        type PdsPreferences = St::PdsPreferences;
-        type CommunicationPreferences = Set<members::communication_preferences>;
         type CreatedAt = St::CreatedAt;
+        type CommunicationPreferences = St::CommunicationPreferences;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type PdsPreferences = St::PdsPreferences;
-        type CommunicationPreferences = St::CommunicationPreferences;
         type CreatedAt = Set<members::created_at>;
+        type CommunicationPreferences = St::CommunicationPreferences;
+    }
+    ///State transition - sets the `communication_preferences` field to Set
+    pub struct SetCommunicationPreferences<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCommunicationPreferences<St> {}
+    impl<St: State> State for SetCommunicationPreferences<St> {
+        type PdsPreferences = St::PdsPreferences;
+        type CreatedAt = St::CreatedAt;
+        type CommunicationPreferences = Set<members::communication_preferences>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `pds_preferences` field
         pub struct pds_preferences(());
-        ///Marker type for the `communication_preferences` field
-        pub struct communication_preferences(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `communication_preferences` field
+        pub struct communication_preferences(());
     }
 }
 
@@ -566,8 +566,8 @@ impl<S: BosStr, St> ProfileBuilder<S, St>
 where
     St: profile_state::State,
     St::PdsPreferences: profile_state::IsSet,
-    St::CommunicationPreferences: profile_state::IsSet,
     St::CreatedAt: profile_state::IsSet,
+    St::CommunicationPreferences: profile_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Profile<S> {
diff --git a/crates/jacquard-api/src/space_litenote/note.rs b/crates/jacquard-api/src/space_litenote/note.rs
index 8fdeaa1a..0398c513 100644
--- a/crates/jacquard-api/src/space_litenote/note.rs
+++ b/crates/jacquard-api/src/space_litenote/note.rs
@@ -584,37 +584,37 @@ pub mod note_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Title;
         type Content;
+        type Title;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Title = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `title` field to Set
-    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTitle<St> {}
-    impl<St: State> State for SetTitle<St> {
-        type Title = Set<members::title>;
-        type Content = St::Content;
+        type Title = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type Title = St::Title;
         type Content = Set<members::content>;
+        type Title = St::Title;
+    }
+    ///State transition - sets the `title` field to Set
+    pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTitle<St> {}
+    impl<St: State> State for SetTitle<St> {
+        type Content = St::Content;
+        type Title = Set<members::title>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `title` field
-        pub struct title(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `title` field
+        pub struct title(());
     }
 }
 
@@ -771,8 +771,8 @@ where
 impl<S: BosStr, St> NoteBuilder<S, St>
 where
     St: note_state::State,
-    St::Title: note_state::IsSet,
     St::Content: note_state::IsSet,
+    St::Title: note_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Note<S> {
diff --git a/crates/jacquard-api/src/st_lifepo/event.rs b/crates/jacquard-api/src/st_lifepo/event.rs
index 0f067b24..64377f38 100644
--- a/crates/jacquard-api/src/st_lifepo/event.rs
+++ b/crates/jacquard-api/src/st_lifepo/event.rs
@@ -78,37 +78,37 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StartDate;
         type Title;
+        type StartDate;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StartDate = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `start_date` field to Set
-    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartDate<St> {}
-    impl<St: State> State for SetStartDate<St> {
-        type StartDate = Set<members::start_date>;
-        type Title = St::Title;
+        type StartDate = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type StartDate = St::StartDate;
         type Title = Set<members::title>;
+        type StartDate = St::StartDate;
+    }
+    ///State transition - sets the `start_date` field to Set
+    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartDate<St> {}
+    impl<St: State> State for SetStartDate<St> {
+        type Title = St::Title;
+        type StartDate = Set<members::start_date>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `start_date` field
-        pub struct start_date(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `start_date` field
+        pub struct start_date(());
     }
 }
 
@@ -204,8 +204,8 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::StartDate: event_state::IsSet,
     St::Title: event_state::IsSet,
+    St::StartDate: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
diff --git a/crates/jacquard-api/src/st_lifepo/profile.rs b/crates/jacquard-api/src/st_lifepo/profile.rs
index e6ca8190..a5b0e3d2 100644
--- a/crates/jacquard-api/src/st_lifepo/profile.rs
+++ b/crates/jacquard-api/src/st_lifepo/profile.rs
@@ -107,37 +107,37 @@ pub mod life_event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type StartDate;
         type Title;
+        type StartDate;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type StartDate = Unset;
         type Title = Unset;
-    }
-    ///State transition - sets the `start_date` field to Set
-    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetStartDate<St> {}
-    impl<St: State> State for SetStartDate<St> {
-        type StartDate = Set<members::start_date>;
-        type Title = St::Title;
+        type StartDate = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTitle<St> {}
     impl<St: State> State for SetTitle<St> {
-        type StartDate = St::StartDate;
         type Title = Set<members::title>;
+        type StartDate = St::StartDate;
+    }
+    ///State transition - sets the `start_date` field to Set
+    pub struct SetStartDate<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetStartDate<St> {}
+    impl<St: State> State for SetStartDate<St> {
+        type Title = St::Title;
+        type StartDate = Set<members::start_date>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `start_date` field
-        pub struct start_date(());
         ///Marker type for the `title` field
         pub struct title(());
+        ///Marker type for the `start_date` field
+        pub struct start_date(());
     }
 }
 
@@ -233,8 +233,8 @@ where
 impl<S: BosStr, St> LifeEventBuilder<S, St>
 where
     St: life_event_state::State,
-    St::StartDate: life_event_state::IsSet,
     St::Title: life_event_state::IsSet,
+    St::StartDate: life_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> LifeEvent<S> {
diff --git a/crates/jacquard-api/src/systems_timker/hawlt/get_note.rs b/crates/jacquard-api/src/systems_timker/hawlt/get_note.rs
index 6eea3471..bc82fe18 100644
--- a/crates/jacquard-api/src/systems_timker/hawlt/get_note.rs
+++ b/crates/jacquard-api/src/systems_timker/hawlt/get_note.rs
@@ -71,37 +71,37 @@ pub mod get_note_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Repo;
         type Rkey;
+        type Repo;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Repo = Unset;
         type Rkey = Unset;
-    }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Repo = Set<members::repo>;
-        type Rkey = St::Rkey;
+        type Repo = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Repo = St::Repo;
         type Rkey = Set<members::rkey>;
+        type Repo = St::Repo;
+    }
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Rkey = St::Rkey;
+        type Repo = Set<members::repo>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `repo` field
-        pub struct repo(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
     }
 }
 
@@ -171,8 +171,8 @@ where
 impl<S: BosStr, St> GetNoteBuilder<S, St>
 where
     St: get_note_state::State,
-    St::Repo: get_note_state::IsSet,
     St::Rkey: get_note_state::IsSet,
+    St::Repo: get_note_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> GetNote<S> {
diff --git a/crates/jacquard-api/src/systems_timker/hawlt/list_notes.rs b/crates/jacquard-api/src/systems_timker/hawlt/list_notes.rs
index ae0bcd05..81b6451e 100644
--- a/crates/jacquard-api/src/systems_timker/hawlt/list_notes.rs
+++ b/crates/jacquard-api/src/systems_timker/hawlt/list_notes.rs
@@ -230,67 +230,67 @@ pub mod note_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type IndexedAt;
         type Uri;
-        type Value;
         type Cid;
-        type IndexedAt;
+        type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type IndexedAt = Unset;
         type Uri = Unset;
-        type Value = Unset;
         type Cid = Unset;
-        type IndexedAt = Unset;
+        type Value = Unset;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type IndexedAt = Set<members::indexed_at>;
+        type Uri = St::Uri;
+        type Cid = St::Cid;
+        type Value = St::Value;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Uri = Set<members::uri>;
-        type Value = St::Value;
-        type Cid = St::Cid;
         type IndexedAt = St::IndexedAt;
-    }
-    ///State transition - sets the `value` field to Set
-    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValue<St> {}
-    impl<St: State> State for SetValue<St> {
-        type Uri = St::Uri;
-        type Value = Set<members::value>;
+        type Uri = Set<members::uri>;
         type Cid = St::Cid;
-        type IndexedAt = St::IndexedAt;
+        type Value = St::Value;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
-        type Value = St::Value;
         type Cid = Set<members::cid>;
-        type IndexedAt = St::IndexedAt;
+        type Value = St::Value;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
+    ///State transition - sets the `value` field to Set
+    pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValue<St> {}
+    impl<St: State> State for SetValue<St> {
+        type IndexedAt = St::IndexedAt;
         type Uri = St::Uri;
-        type Value = St::Value;
         type Cid = St::Cid;
-        type IndexedAt = Set<members::indexed_at>;
+        type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `value` field
-        pub struct value(());
         ///Marker type for the `cid` field
         pub struct cid(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
+        ///Marker type for the `value` field
+        pub struct value(());
     }
 }
 
@@ -398,10 +398,10 @@ where
 impl<S: BosStr, St> NoteViewBuilder<S, St>
 where
     St: note_view_state::State,
+    St::IndexedAt: note_view_state::IsSet,
     St::Uri: note_view_state::IsSet,
-    St::Value: note_view_state::IsSet,
     St::Cid: note_view_state::IsSet,
-    St::IndexedAt: note_view_state::IsSet,
+    St::Value: note_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> NoteView<S> {
diff --git a/crates/jacquard-api/src/systems_timker/hawlt/put_note.rs b/crates/jacquard-api/src/systems_timker/hawlt/put_note.rs
index 3c29043b..178e5ed0 100644
--- a/crates/jacquard-api/src/systems_timker/hawlt/put_note.rs
+++ b/crates/jacquard-api/src/systems_timker/hawlt/put_note.rs
@@ -77,37 +77,37 @@ pub mod put_note_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Record;
         type Rkey;
+        type Record;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Record = Unset;
         type Rkey = Unset;
-    }
-    ///State transition - sets the `record` field to Set
-    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecord<St> {}
-    impl<St: State> State for SetRecord<St> {
-        type Record = Set<members::record>;
-        type Rkey = St::Rkey;
+        type Record = Unset;
     }
     ///State transition - sets the `rkey` field to Set
     pub struct SetRkey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRkey<St> {}
     impl<St: State> State for SetRkey<St> {
-        type Record = St::Record;
         type Rkey = Set<members::rkey>;
+        type Record = St::Record;
+    }
+    ///State transition - sets the `record` field to Set
+    pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecord<St> {}
+    impl<St: State> State for SetRecord<St> {
+        type Rkey = St::Rkey;
+        type Record = Set<members::record>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `record` field
-        pub struct record(());
         ///Marker type for the `rkey` field
         pub struct rkey(());
+        ///Marker type for the `record` field
+        pub struct record(());
     }
 }
 
@@ -177,8 +177,8 @@ where
 impl<S: BosStr, St> PutNoteBuilder<S, St>
 where
     St: put_note_state::State,
-    St::Record: put_note_state::IsSet,
     St::Rkey: put_note_state::IsSet,
+    St::Record: put_note_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PutNote<S> {
diff --git a/crates/jacquard-api/src/tech_lenooby09/didgit/object.rs b/crates/jacquard-api/src/tech_lenooby09/didgit/object.rs
index be1b1ad2..1857a35a 100644
--- a/crates/jacquard-api/src/tech_lenooby09/didgit/object.rs
+++ b/crates/jacquard-api/src/tech_lenooby09/didgit/object.rs
@@ -253,37 +253,37 @@ pub mod object_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ObjectType;
         type Content;
+        type ObjectType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ObjectType = Unset;
         type Content = Unset;
-    }
-    ///State transition - sets the `object_type` field to Set
-    pub struct SetObjectType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObjectType<St> {}
-    impl<St: State> State for SetObjectType<St> {
-        type ObjectType = Set<members::object_type>;
-        type Content = St::Content;
+        type ObjectType = Unset;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
-        type ObjectType = St::ObjectType;
         type Content = Set<members::content>;
+        type ObjectType = St::ObjectType;
+    }
+    ///State transition - sets the `object_type` field to Set
+    pub struct SetObjectType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObjectType<St> {}
+    impl<St: State> State for SetObjectType<St> {
+        type Content = St::Content;
+        type ObjectType = Set<members::object_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `object_type` field
-        pub struct object_type(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `object_type` field
+        pub struct object_type(());
     }
 }
 
@@ -353,8 +353,8 @@ where
 impl<S: BosStr, St> ObjectBuilder<S, St>
 where
     St: object_state::State,
-    St::ObjectType: object_state::IsSet,
     St::Content: object_state::IsSet,
+    St::ObjectType: object_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Object<S> {
diff --git a/crates/jacquard-api/src/tech_lenooby09/didgit/ref.rs b/crates/jacquard-api/src/tech_lenooby09/didgit/ref.rs
index b581ce06..cce31e25 100644
--- a/crates/jacquard-api/src/tech_lenooby09/didgit/ref.rs
+++ b/crates/jacquard-api/src/tech_lenooby09/didgit/ref.rs
@@ -150,50 +150,50 @@ pub mod ref_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type RefName;
-        type ObjectId;
         type Repo;
+        type ObjectId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type RefName = Unset;
-        type ObjectId = Unset;
         type Repo = Unset;
+        type ObjectId = Unset;
     }
     ///State transition - sets the `ref_name` field to Set
     pub struct SetRefName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRefName<St> {}
     impl<St: State> State for SetRefName<St> {
         type RefName = Set<members::ref_name>;
-        type ObjectId = St::ObjectId;
-        type Repo = St::Repo;
-    }
-    ///State transition - sets the `object_id` field to Set
-    pub struct SetObjectId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObjectId<St> {}
-    impl<St: State> State for SetObjectId<St> {
-        type RefName = St::RefName;
-        type ObjectId = Set<members::object_id>;
         type Repo = St::Repo;
+        type ObjectId = St::ObjectId;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
         type RefName = St::RefName;
-        type ObjectId = St::ObjectId;
         type Repo = Set<members::repo>;
+        type ObjectId = St::ObjectId;
+    }
+    ///State transition - sets the `object_id` field to Set
+    pub struct SetObjectId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObjectId<St> {}
+    impl<St: State> State for SetObjectId<St> {
+        type RefName = St::RefName;
+        type Repo = St::Repo;
+        type ObjectId = Set<members::object_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `ref_name` field
         pub struct ref_name(());
-        ///Marker type for the `object_id` field
-        pub struct object_id(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `object_id` field
+        pub struct object_id(());
     }
 }
 
@@ -280,8 +280,8 @@ impl<S: BosStr, St> RefBuilder<S, St>
 where
     St: ref_state::State,
     St::RefName: ref_state::IsSet,
-    St::ObjectId: ref_state::IsSet,
     St::Repo: ref_state::IsSet,
+    St::ObjectId: ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Ref<S> {
diff --git a/crates/jacquard-api/src/tech_lenooby09/didgit/signature_proof.rs b/crates/jacquard-api/src/tech_lenooby09/didgit/signature_proof.rs
index 608f12ec..19bdfa87 100644
--- a/crates/jacquard-api/src/tech_lenooby09/didgit/signature_proof.rs
+++ b/crates/jacquard-api/src/tech_lenooby09/didgit/signature_proof.rs
@@ -280,105 +280,105 @@ pub mod signature_proof_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Signer;
-        type ObjectType;
-        type ObjectId;
         type SignatureType;
-        type SignedAt;
         type Signature;
+        type SignedAt;
+        type ObjectId;
+        type ObjectType;
+        type Signer;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Signer = Unset;
-        type ObjectType = Unset;
-        type ObjectId = Unset;
         type SignatureType = Unset;
-        type SignedAt = Unset;
         type Signature = Unset;
+        type SignedAt = Unset;
+        type ObjectId = Unset;
+        type ObjectType = Unset;
+        type Signer = Unset;
     }
-    ///State transition - sets the `signer` field to Set
-    pub struct SetSigner<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSigner<St> {}
-    impl<St: State> State for SetSigner<St> {
-        type Signer = Set<members::signer>;
-        type ObjectType = St::ObjectType;
+    ///State transition - sets the `signature_type` field to Set
+    pub struct SetSignatureType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSignatureType<St> {}
+    impl<St: State> State for SetSignatureType<St> {
+        type SignatureType = Set<members::signature_type>;
+        type Signature = St::Signature;
+        type SignedAt = St::SignedAt;
         type ObjectId = St::ObjectId;
+        type ObjectType = St::ObjectType;
+        type Signer = St::Signer;
+    }
+    ///State transition - sets the `signature` field to Set
+    pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSignature<St> {}
+    impl<St: State> State for SetSignature<St> {
         type SignatureType = St::SignatureType;
+        type Signature = Set<members::signature>;
         type SignedAt = St::SignedAt;
-        type Signature = St::Signature;
-    }
-    ///State transition - sets the `object_type` field to Set
-    pub struct SetObjectType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetObjectType<St> {}
-    impl<St: State> State for SetObjectType<St> {
-        type Signer = St::Signer;
-        type ObjectType = Set<members::object_type>;
         type ObjectId = St::ObjectId;
+        type ObjectType = St::ObjectType;
+        type Signer = St::Signer;
+    }
+    ///State transition - sets the `signed_at` field to Set
+    pub struct SetSignedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSignedAt<St> {}
+    impl<St: State> State for SetSignedAt<St> {
         type SignatureType = St::SignatureType;
-        type SignedAt = St::SignedAt;
         type Signature = St::Signature;
+        type SignedAt = Set<members::signed_at>;
+        type ObjectId = St::ObjectId;
+        type ObjectType = St::ObjectType;
+        type Signer = St::Signer;
     }
     ///State transition - sets the `object_id` field to Set
     pub struct SetObjectId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetObjectId<St> {}
     impl<St: State> State for SetObjectId<St> {
-        type Signer = St::Signer;
-        type ObjectType = St::ObjectType;
-        type ObjectId = Set<members::object_id>;
         type SignatureType = St::SignatureType;
-        type SignedAt = St::SignedAt;
         type Signature = St::Signature;
-    }
-    ///State transition - sets the `signature_type` field to Set
-    pub struct SetSignatureType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSignatureType<St> {}
-    impl<St: State> State for SetSignatureType<St> {
-        type Signer = St::Signer;
-        type ObjectType = St::ObjectType;
-        type ObjectId = St::ObjectId;
-        type SignatureType = Set<members::signature_type>;
         type SignedAt = St::SignedAt;
-        type Signature = St::Signature;
-    }
-    ///State transition - sets the `signed_at` field to Set
-    pub struct SetSignedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSignedAt<St> {}
-    impl<St: State> State for SetSignedAt<St> {
-        type Signer = St::Signer;
+        type ObjectId = Set<members::object_id>;
         type ObjectType = St::ObjectType;
-        type ObjectId = St::ObjectId;
+        type Signer = St::Signer;
+    }
+    ///State transition - sets the `object_type` field to Set
+    pub struct SetObjectType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetObjectType<St> {}
+    impl<St: State> State for SetObjectType<St> {
         type SignatureType = St::SignatureType;
-        type SignedAt = Set<members::signed_at>;
         type Signature = St::Signature;
-    }
-    ///State transition - sets the `signature` field to Set
-    pub struct SetSignature<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSignature<St> {}
-    impl<St: State> State for SetSignature<St> {
-        type Signer = St::Signer;
-        type ObjectType = St::ObjectType;
+        type SignedAt = St::SignedAt;
         type ObjectId = St::ObjectId;
+        type ObjectType = Set<members::object_type>;
+        type Signer = St::Signer;
+    }
+    ///State transition - sets the `signer` field to Set
+    pub struct SetSigner<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSigner<St> {}
+    impl<St: State> State for SetSigner<St> {
         type SignatureType = St::SignatureType;
+        type Signature = St::Signature;
         type SignedAt = St::SignedAt;
-        type Signature = Set<members::signature>;
+        type ObjectId = St::ObjectId;
+        type ObjectType = St::ObjectType;
+        type Signer = Set<members::signer>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `signer` field
-        pub struct signer(());
-        ///Marker type for the `object_type` field
-        pub struct object_type(());
-        ///Marker type for the `object_id` field
-        pub struct object_id(());
         ///Marker type for the `signature_type` field
         pub struct signature_type(());
-        ///Marker type for the `signed_at` field
-        pub struct signed_at(());
         ///Marker type for the `signature` field
         pub struct signature(());
+        ///Marker type for the `signed_at` field
+        pub struct signed_at(());
+        ///Marker type for the `object_id` field
+        pub struct object_id(());
+        ///Marker type for the `object_type` field
+        pub struct object_type(());
+        ///Marker type for the `signer` field
+        pub struct signer(());
     }
 }
 
@@ -545,12 +545,12 @@ where
 impl<S: BosStr, St> SignatureProofBuilder<S, St>
 where
     St: signature_proof_state::State,
-    St::Signer: signature_proof_state::IsSet,
-    St::ObjectType: signature_proof_state::IsSet,
-    St::ObjectId: signature_proof_state::IsSet,
     St::SignatureType: signature_proof_state::IsSet,
-    St::SignedAt: signature_proof_state::IsSet,
     St::Signature: signature_proof_state::IsSet,
+    St::SignedAt: signature_proof_state::IsSet,
+    St::ObjectId: signature_proof_state::IsSet,
+    St::ObjectType: signature_proof_state::IsSet,
+    St::Signer: signature_proof_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SignatureProof<S> {
diff --git a/crates/jacquard-api/src/tech_manos/twmirror/post.rs b/crates/jacquard-api/src/tech_manos/twmirror/post.rs
index e5abd00a..1c2c420b 100644
--- a/crates/jacquard-api/src/tech_manos/twmirror/post.rs
+++ b/crates/jacquard-api/src/tech_manos/twmirror/post.rs
@@ -120,65 +120,65 @@ pub mod post_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type TwUserId;
         type BskyPost;
+        type TwUserId;
+        type CreatedAt;
         type TweetId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type TwUserId = Unset;
         type BskyPost = Unset;
+        type TwUserId = Unset;
+        type CreatedAt = Unset;
         type TweetId = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
+    ///State transition - sets the `bsky_post` field to Set
+    pub struct SetBskyPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBskyPost<St> {}
+    impl<St: State> State for SetBskyPost<St> {
+        type BskyPost = Set<members::bsky_post>;
         type TwUserId = St::TwUserId;
-        type BskyPost = St::BskyPost;
+        type CreatedAt = St::CreatedAt;
         type TweetId = St::TweetId;
     }
     ///State transition - sets the `tw_user_id` field to Set
     pub struct SetTwUserId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTwUserId<St> {}
     impl<St: State> State for SetTwUserId<St> {
-        type CreatedAt = St::CreatedAt;
-        type TwUserId = Set<members::tw_user_id>;
         type BskyPost = St::BskyPost;
+        type TwUserId = Set<members::tw_user_id>;
+        type CreatedAt = St::CreatedAt;
         type TweetId = St::TweetId;
     }
-    ///State transition - sets the `bsky_post` field to Set
-    pub struct SetBskyPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBskyPost<St> {}
-    impl<St: State> State for SetBskyPost<St> {
-        type CreatedAt = St::CreatedAt;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type BskyPost = St::BskyPost;
         type TwUserId = St::TwUserId;
-        type BskyPost = Set<members::bsky_post>;
+        type CreatedAt = Set<members::created_at>;
         type TweetId = St::TweetId;
     }
     ///State transition - sets the `tweet_id` field to Set
     pub struct SetTweetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTweetId<St> {}
     impl<St: State> State for SetTweetId<St> {
-        type CreatedAt = St::CreatedAt;
-        type TwUserId = St::TwUserId;
         type BskyPost = St::BskyPost;
+        type TwUserId = St::TwUserId;
+        type CreatedAt = St::CreatedAt;
         type TweetId = Set<members::tweet_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `tw_user_id` field
-        pub struct tw_user_id(());
         ///Marker type for the `bsky_post` field
         pub struct bsky_post(());
+        ///Marker type for the `tw_user_id` field
+        pub struct tw_user_id(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `tweet_id` field
         pub struct tweet_id(());
     }
@@ -293,9 +293,9 @@ where
 impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
-    St::CreatedAt: post_state::IsSet,
-    St::TwUserId: post_state::IsSet,
     St::BskyPost: post_state::IsSet,
+    St::TwUserId: post_state::IsSet,
+    St::CreatedAt: post_state::IsSet,
     St::TweetId: post_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/tech_tokimeki/kaku.rs b/crates/jacquard-api/src/tech_tokimeki/kaku.rs
index 8a763a64..73584e5b 100644
--- a/crates/jacquard-api/src/tech_tokimeki/kaku.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/kaku.rs
@@ -614,37 +614,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -714,8 +714,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Width: aspect_ratio_state::IsSet,
     St::Height: aspect_ratio_state::IsSet,
+    St::Width: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
@@ -1382,83 +1382,83 @@ pub mod collection_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Author;
         type Cid;
+        type CreatedAt;
         type Name;
+        type Author;
         type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Author = Unset;
         type Cid = Unset;
+        type CreatedAt = Unset;
         type Name = Unset;
+        type Author = Unset;
         type Uri = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Author = St::Author;
-        type Cid = St::Cid;
-        type Name = St::Name;
-        type Uri = St::Uri;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type CreatedAt = St::CreatedAt;
-        type Author = Set<members::author>;
-        type Cid = St::Cid;
-        type Name = St::Name;
-        type Uri = St::Uri;
-    }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
         type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
         type Author = St::Author;
-        type Cid = Set<members::cid>;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Cid = St::Cid;
+        type CreatedAt = Set<members::created_at>;
         type Name = St::Name;
+        type Author = St::Author;
         type Uri = St::Uri;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
         type Author = St::Author;
+        type Uri = St::Uri;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
         type Cid = St::Cid;
-        type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
+        type Author = Set<members::author>;
         type Uri = St::Uri;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type CreatedAt = St::CreatedAt;
-        type Author = St::Author;
         type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
         type Name = St::Name;
+        type Author = St::Author;
         type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `author` field
-        pub struct author(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `author` field
+        pub struct author(());
         ///Marker type for the `uri` field
         pub struct uri(());
     }
@@ -1649,10 +1649,10 @@ where
 impl<S: BosStr, St> CollectionViewBuilder<S, St>
 where
     St: collection_view_state::State,
-    St::CreatedAt: collection_view_state::IsSet,
-    St::Author: collection_view_state::IsSet,
     St::Cid: collection_view_state::IsSet,
+    St::CreatedAt: collection_view_state::IsSet,
     St::Name: collection_view_state::IsSet,
+    St::Author: collection_view_state::IsSet,
     St::Uri: collection_view_state::IsSet,
 {
     /// Build the final struct.
@@ -1700,105 +1700,105 @@ pub mod post_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Image;
         type Uri;
+        type Cid;
         type Author;
-        type CreatedAt;
+        type Image;
         type AspectRatio;
-        type Cid;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Image = Unset;
         type Uri = Unset;
+        type Cid = Unset;
         type Author = Unset;
-        type CreatedAt = Unset;
+        type Image = Unset;
         type AspectRatio = Unset;
-        type Cid = Unset;
-    }
-    ///State transition - sets the `image` field to Set
-    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetImage<St> {}
-    impl<St: State> State for SetImage<St> {
-        type Image = Set<members::image>;
-        type Uri = St::Uri;
-        type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
-        type AspectRatio = St::AspectRatio;
-        type Cid = St::Cid;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Image = St::Image;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
         type Author = St::Author;
+        type Image = St::Image;
+        type AspectRatio = St::AspectRatio;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
+        type Author = St::Author;
+        type Image = St::Image;
         type AspectRatio = St::AspectRatio;
-        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Image = St::Image;
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Author = Set<members::author>;
-        type CreatedAt = St::CreatedAt;
+        type Image = St::Image;
         type AspectRatio = St::AspectRatio;
-        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Image = St::Image;
+    ///State transition - sets the `image` field to Set
+    pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetImage<St> {}
+    impl<St: State> State for SetImage<St> {
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Author = St::Author;
-        type CreatedAt = Set<members::created_at>;
+        type Image = Set<members::image>;
         type AspectRatio = St::AspectRatio;
-        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `aspect_ratio` field to Set
     pub struct SetAspectRatio<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAspectRatio<St> {}
     impl<St: State> State for SetAspectRatio<St> {
-        type Image = St::Image;
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
+        type Image = St::Image;
         type AspectRatio = Set<members::aspect_ratio>;
-        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Image = St::Image;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Author = St::Author;
-        type CreatedAt = St::CreatedAt;
+        type Image = St::Image;
         type AspectRatio = St::AspectRatio;
-        type Cid = Set<members::cid>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `image` field
-        pub struct image(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `image` field
+        pub struct image(());
         ///Marker type for the `aspect_ratio` field
         pub struct aspect_ratio(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -2060,12 +2060,12 @@ impl<S: BosStr, St: post_view_state::State> PostViewBuilder<S, St> {
 impl<S: BosStr, St> PostViewBuilder<S, St>
 where
     St: post_view_state::State,
-    St::Image: post_view_state::IsSet,
     St::Uri: post_view_state::IsSet,
+    St::Cid: post_view_state::IsSet,
     St::Author: post_view_state::IsSet,
-    St::CreatedAt: post_view_state::IsSet,
+    St::Image: post_view_state::IsSet,
     St::AspectRatio: post_view_state::IsSet,
-    St::Cid: post_view_state::IsSet,
+    St::CreatedAt: post_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> PostView<S> {
@@ -2148,83 +2148,83 @@ pub mod reply_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
         type Author;
-        type Cid;
         type Text;
-        type Uri;
+        type Cid;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
         type Author = Unset;
-        type Cid = Unset;
         type Text = Unset;
-        type Uri = Unset;
+        type Cid = Unset;
         type CreatedAt = Unset;
     }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
+        type Author = St::Author;
+        type Text = St::Text;
+        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
+    }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type Author = Set<members::author>;
-        type Cid = St::Cid;
-        type Text = St::Text;
         type Uri = St::Uri;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Author = St::Author;
-        type Cid = Set<members::cid>;
+        type Author = Set<members::author>;
         type Text = St::Text;
-        type Uri = St::Uri;
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
+        type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = St::Cid;
         type Text = Set<members::text>;
-        type Uri = St::Uri;
+        type Cid = St::Cid;
         type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = St::Cid;
         type Text = St::Text;
-        type Uri = Set<members::uri>;
+        type Cid = Set<members::cid>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = St::Cid;
         type Text = St::Text;
-        type Uri = St::Uri;
+        type Cid = St::Cid;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `text` field
         pub struct text(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -2359,10 +2359,10 @@ where
 impl<S: BosStr, St> ReplyViewBuilder<S, St>
 where
     St: reply_view_state::State,
+    St::Uri: reply_view_state::IsSet,
     St::Author: reply_view_state::IsSet,
-    St::Cid: reply_view_state::IsSet,
     St::Text: reply_view_state::IsSet,
-    St::Uri: reply_view_state::IsSet,
+    St::Cid: reply_view_state::IsSet,
     St::CreatedAt: reply_view_state::IsSet,
 {
     /// Build the final struct.
@@ -2402,85 +2402,85 @@ pub mod request_response_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
-        type Post;
+        type Cid;
         type Uri;
         type Author;
-        type Cid;
+        type CreatedAt;
+        type Post;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
-        type Post = Unset;
+        type Cid = Unset;
         type Uri = Unset;
         type Author = Unset;
-        type Cid = Unset;
+        type CreatedAt = Unset;
+        type Post = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Post = St::Post;
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Cid = Set<members::cid>;
         type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `post` field to Set
-    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPost<St> {}
-    impl<St: State> State for SetPost<St> {
         type CreatedAt = St::CreatedAt;
-        type Post = Set<members::post>;
-        type Uri = St::Uri;
-        type Author = St::Author;
-        type Cid = St::Cid;
+        type Post = St::Post;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type CreatedAt = St::CreatedAt;
-        type Post = St::Post;
+        type Cid = St::Cid;
         type Uri = Set<members::uri>;
         type Author = St::Author;
-        type Cid = St::Cid;
+        type CreatedAt = St::CreatedAt;
+        type Post = St::Post;
     }
     ///State transition - sets the `author` field to Set
     pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAuthor<St> {}
     impl<St: State> State for SetAuthor<St> {
-        type CreatedAt = St::CreatedAt;
-        type Post = St::Post;
+        type Cid = St::Cid;
         type Uri = St::Uri;
         type Author = Set<members::author>;
-        type Cid = St::Cid;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
         type CreatedAt = St::CreatedAt;
         type Post = St::Post;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Cid = St::Cid;
         type Uri = St::Uri;
         type Author = St::Author;
-        type Cid = Set<members::cid>;
+        type CreatedAt = Set<members::created_at>;
+        type Post = St::Post;
+    }
+    ///State transition - sets the `post` field to Set
+    pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPost<St> {}
+    impl<St: State> State for SetPost<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
+        type Author = St::Author;
+        type CreatedAt = St::CreatedAt;
+        type Post = Set<members::post>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `post` field
-        pub struct post(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `author` field
         pub struct author(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `post` field
+        pub struct post(());
     }
 }
 
@@ -2633,11 +2633,11 @@ where
 impl<S: BosStr, St> RequestResponseViewBuilder<S, St>
 where
     St: request_response_view_state::State,
-    St::CreatedAt: request_response_view_state::IsSet,
-    St::Post: request_response_view_state::IsSet,
+    St::Cid: request_response_view_state::IsSet,
     St::Uri: request_response_view_state::IsSet,
     St::Author: request_response_view_state::IsSet,
-    St::Cid: request_response_view_state::IsSet,
+    St::CreatedAt: request_response_view_state::IsSet,
+    St::Post: request_response_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RequestResponseView<S> {
@@ -2680,10 +2680,10 @@ pub mod request_view_state {
     pub trait State: sealed::Sealed {
         type Cid;
         type Uri;
+        type Author;
+        type CreatedAt;
         type Text;
         type IsOpen;
-        type CreatedAt;
-        type Author;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -2691,10 +2691,10 @@ pub mod request_view_state {
     impl State for Empty {
         type Cid = Unset;
         type Uri = Unset;
+        type Author = Unset;
+        type CreatedAt = Unset;
         type Text = Unset;
         type IsOpen = Unset;
-        type CreatedAt = Unset;
-        type Author = Unset;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
@@ -2702,10 +2702,10 @@ pub mod request_view_state {
     impl<St: State> State for SetCid<St> {
         type Cid = Set<members::cid>;
         type Uri = St::Uri;
+        type Author = St::Author;
+        type CreatedAt = St::CreatedAt;
         type Text = St::Text;
         type IsOpen = St::IsOpen;
-        type CreatedAt = St::CreatedAt;
-        type Author = St::Author;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
@@ -2713,10 +2713,32 @@ pub mod request_view_state {
     impl<St: State> State for SetUri<St> {
         type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Author = St::Author;
+        type CreatedAt = St::CreatedAt;
         type Text = St::Text;
         type IsOpen = St::IsOpen;
+    }
+    ///State transition - sets the `author` field to Set
+    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAuthor<St> {}
+    impl<St: State> State for SetAuthor<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
+        type Author = Set<members::author>;
         type CreatedAt = St::CreatedAt;
+        type Text = St::Text;
+        type IsOpen = St::IsOpen;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Cid = St::Cid;
+        type Uri = St::Uri;
         type Author = St::Author;
+        type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+        type IsOpen = St::IsOpen;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
@@ -2724,10 +2746,10 @@ pub mod request_view_state {
     impl<St: State> State for SetText<St> {
         type Cid = St::Cid;
         type Uri = St::Uri;
+        type Author = St::Author;
+        type CreatedAt = St::CreatedAt;
         type Text = Set<members::text>;
         type IsOpen = St::IsOpen;
-        type CreatedAt = St::CreatedAt;
-        type Author = St::Author;
     }
     ///State transition - sets the `is_open` field to Set
     pub struct SetIsOpen<St: State = Empty>(PhantomData<fn() -> St>);
@@ -2735,32 +2757,10 @@ pub mod request_view_state {
     impl<St: State> State for SetIsOpen<St> {
         type Cid = St::Cid;
         type Uri = St::Uri;
-        type Text = St::Text;
-        type IsOpen = Set<members::is_open>;
-        type CreatedAt = St::CreatedAt;
-        type Author = St::Author;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Cid = St::Cid;
-        type Uri = St::Uri;
-        type Text = St::Text;
-        type IsOpen = St::IsOpen;
-        type CreatedAt = Set<members::created_at>;
         type Author = St::Author;
-    }
-    ///State transition - sets the `author` field to Set
-    pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAuthor<St> {}
-    impl<St: State> State for SetAuthor<St> {
-        type Cid = St::Cid;
-        type Uri = St::Uri;
-        type Text = St::Text;
-        type IsOpen = St::IsOpen;
         type CreatedAt = St::CreatedAt;
-        type Author = Set<members::author>;
+        type Text = St::Text;
+        type IsOpen = Set<members::is_open>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -2769,14 +2769,14 @@ pub mod request_view_state {
         pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `author` field
+        pub struct author(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `text` field
         pub struct text(());
         ///Marker type for the `is_open` field
         pub struct is_open(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `author` field
-        pub struct author(());
     }
 }
 
@@ -3007,10 +3007,10 @@ where
     St: request_view_state::State,
     St::Cid: request_view_state::IsSet,
     St::Uri: request_view_state::IsSet,
+    St::Author: request_view_state::IsSet,
+    St::CreatedAt: request_view_state::IsSet,
     St::Text: request_view_state::IsSet,
     St::IsOpen: request_view_state::IsSet,
-    St::CreatedAt: request_view_state::IsSet,
-    St::Author: request_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RequestView<S> {
diff --git a/crates/jacquard-api/src/tech_tokimeki/kaku/collection.rs b/crates/jacquard-api/src/tech_tokimeki/kaku/collection.rs
index c165bba9..081f1354 100644
--- a/crates/jacquard-api/src/tech_tokimeki/kaku/collection.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/kaku/collection.rs
@@ -181,37 +181,37 @@ pub mod collection_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Name;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -307,8 +307,8 @@ where
 impl<S: BosStr, St> CollectionBuilder<S, St>
 where
     St: collection_state::State,
-    St::CreatedAt: collection_state::IsSet,
     St::Name: collection_state::IsSet,
+    St::CreatedAt: collection_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Collection<S> {
diff --git a/crates/jacquard-api/src/tech_tokimeki/kaku/collection_item.rs b/crates/jacquard-api/src/tech_tokimeki/kaku/collection_item.rs
index afd05658..f54b9d51 100644
--- a/crates/jacquard-api/src/tech_tokimeki/kaku/collection_item.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/kaku/collection_item.rs
@@ -128,49 +128,49 @@ pub mod collection_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Collection;
         type Post;
+        type Collection;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Collection = Unset;
         type Post = Unset;
+        type Collection = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `collection` field to Set
-    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCollection<St> {}
-    impl<St: State> State for SetCollection<St> {
-        type Collection = Set<members::collection>;
-        type Post = St::Post;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `post` field to Set
     pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPost<St> {}
     impl<St: State> State for SetPost<St> {
-        type Collection = St::Collection;
         type Post = Set<members::post>;
+        type Collection = St::Collection;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `collection` field to Set
+    pub struct SetCollection<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCollection<St> {}
+    impl<St: State> State for SetCollection<St> {
+        type Post = St::Post;
+        type Collection = Set<members::collection>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Collection = St::Collection;
         type Post = St::Post;
+        type Collection = St::Collection;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `collection` field
-        pub struct collection(());
         ///Marker type for the `post` field
         pub struct post(());
+        ///Marker type for the `collection` field
+        pub struct collection(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -274,8 +274,8 @@ where
 impl<S: BosStr, St> CollectionItemBuilder<S, St>
 where
     St: collection_item_state::State,
-    St::Collection: collection_item_state::IsSet,
     St::Post: collection_item_state::IsSet,
+    St::Collection: collection_item_state::IsSet,
     St::CreatedAt: collection_item_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/tech_tokimeki/kaku/reaction.rs b/crates/jacquard-api/src/tech_tokimeki/kaku/reaction.rs
index 6d7f505f..1c6e9e63 100644
--- a/crates/jacquard-api/src/tech_tokimeki/kaku/reaction.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/kaku/reaction.rs
@@ -207,51 +207,51 @@ pub mod reaction_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Type;
         type CreatedAt;
         type Subject;
-        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Type = Unset;
         type CreatedAt = Unset;
         type Subject = Unset;
-        type Type = Unset;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Type = Set<members::r#type>;
+        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type Type = St::Type;
         type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
-        type Type = St::Type;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type CreatedAt = St::CreatedAt;
-        type Subject = Set<members::subject>;
         type Type = St::Type;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
         type CreatedAt = St::CreatedAt;
-        type Subject = St::Subject;
-        type Type = Set<members::r#type>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `type` field
+        pub struct r#type(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `type` field
-        pub struct r#type(());
     }
 }
 
@@ -340,9 +340,9 @@ where
 impl<S: BosStr, St> ReactionBuilder<S, St>
 where
     St: reaction_state::State,
+    St::Type: reaction_state::IsSet,
     St::CreatedAt: reaction_state::IsSet,
     St::Subject: reaction_state::IsSet,
-    St::Type: reaction_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Reaction<S> {
diff --git a/crates/jacquard-api/src/tech_tokimeki/kaku/request_response.rs b/crates/jacquard-api/src/tech_tokimeki/kaku/request_response.rs
index adbcb8d6..2bd33c66 100644
--- a/crates/jacquard-api/src/tech_tokimeki/kaku/request_response.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/kaku/request_response.rs
@@ -141,51 +141,51 @@ pub mod request_response_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Request;
         type Post;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Request = Unset;
         type Post = Unset;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Request = St::Request;
-        type Post = St::Post;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `request` field to Set
     pub struct SetRequest<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRequest<St> {}
     impl<St: State> State for SetRequest<St> {
-        type CreatedAt = St::CreatedAt;
         type Request = Set<members::request>;
         type Post = St::Post;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `post` field to Set
     pub struct SetPost<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPost<St> {}
     impl<St: State> State for SetPost<St> {
-        type CreatedAt = St::CreatedAt;
         type Request = St::Request;
         type Post = Set<members::post>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Request = St::Request;
+        type Post = St::Post;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `request` field
         pub struct request(());
         ///Marker type for the `post` field
         pub struct post(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -287,9 +287,9 @@ where
 impl<S: BosStr, St> RequestResponseBuilder<S, St>
 where
     St: request_response_state::State,
-    St::CreatedAt: request_response_state::IsSet,
     St::Request: request_response_state::IsSet,
     St::Post: request_response_state::IsSet,
+    St::CreatedAt: request_response_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RequestResponse<S> {
diff --git a/crates/jacquard-api/src/tech_tokimeki/poll/vote.rs b/crates/jacquard-api/src/tech_tokimeki/poll/vote.rs
index 6c3d59fc..b554baac 100644
--- a/crates/jacquard-api/src/tech_tokimeki/poll/vote.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/poll/vote.rs
@@ -136,49 +136,49 @@ pub mod vote_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type OptionIndex;
         type CreatedAt;
+        type OptionIndex;
         type Poll;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type OptionIndex = Unset;
         type CreatedAt = Unset;
+        type OptionIndex = Unset;
         type Poll = Unset;
     }
-    ///State transition - sets the `option_index` field to Set
-    pub struct SetOptionIndex<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetOptionIndex<St> {}
-    impl<St: State> State for SetOptionIndex<St> {
-        type OptionIndex = Set<members::option_index>;
-        type CreatedAt = St::CreatedAt;
-        type Poll = St::Poll;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type OptionIndex = St::OptionIndex;
         type CreatedAt = Set<members::created_at>;
+        type OptionIndex = St::OptionIndex;
+        type Poll = St::Poll;
+    }
+    ///State transition - sets the `option_index` field to Set
+    pub struct SetOptionIndex<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetOptionIndex<St> {}
+    impl<St: State> State for SetOptionIndex<St> {
+        type CreatedAt = St::CreatedAt;
+        type OptionIndex = Set<members::option_index>;
         type Poll = St::Poll;
     }
     ///State transition - sets the `poll` field to Set
     pub struct SetPoll<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPoll<St> {}
     impl<St: State> State for SetPoll<St> {
-        type OptionIndex = St::OptionIndex;
         type CreatedAt = St::CreatedAt;
+        type OptionIndex = St::OptionIndex;
         type Poll = Set<members::poll>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `option_index` field
-        pub struct option_index(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `option_index` field
+        pub struct option_index(());
         ///Marker type for the `poll` field
         pub struct poll(());
     }
@@ -269,8 +269,8 @@ where
 impl<S: BosStr, St> VoteBuilder<S, St>
 where
     St: vote_state::State,
-    St::OptionIndex: vote_state::IsSet,
     St::CreatedAt: vote_state::IsSet,
+    St::OptionIndex: vote_state::IsSet,
     St::Poll: vote_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/tech_tokimeki/takibi/log.rs b/crates/jacquard-api/src/tech_tokimeki/takibi/log.rs
index 887710ba..c256f41f 100644
--- a/crates/jacquard-api/src/tech_tokimeki/takibi/log.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/takibi/log.rs
@@ -385,37 +385,37 @@ pub mod spark_ref_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Spark;
         type Elapsed;
+        type Spark;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Spark = Unset;
         type Elapsed = Unset;
-    }
-    ///State transition - sets the `spark` field to Set
-    pub struct SetSpark<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSpark<St> {}
-    impl<St: State> State for SetSpark<St> {
-        type Spark = Set<members::spark>;
-        type Elapsed = St::Elapsed;
+        type Spark = Unset;
     }
     ///State transition - sets the `elapsed` field to Set
     pub struct SetElapsed<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetElapsed<St> {}
     impl<St: State> State for SetElapsed<St> {
-        type Spark = St::Spark;
         type Elapsed = Set<members::elapsed>;
+        type Spark = St::Spark;
+    }
+    ///State transition - sets the `spark` field to Set
+    pub struct SetSpark<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSpark<St> {}
+    impl<St: State> State for SetSpark<St> {
+        type Elapsed = St::Elapsed;
+        type Spark = Set<members::spark>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `spark` field
-        pub struct spark(());
         ///Marker type for the `elapsed` field
         pub struct elapsed(());
+        ///Marker type for the `spark` field
+        pub struct spark(());
     }
 }
 
@@ -485,8 +485,8 @@ where
 impl<S: BosStr, St> SparkRefBuilder<S, St>
 where
     St: spark_ref_state::State,
-    St::Spark: spark_ref_state::IsSet,
     St::Elapsed: spark_ref_state::IsSet,
+    St::Spark: spark_ref_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SparkRef<S> {
diff --git a/crates/jacquard-api/src/tech_tokimeki/takibi/spark.rs b/crates/jacquard-api/src/tech_tokimeki/takibi/spark.rs
index 574cac30..09ae3456 100644
--- a/crates/jacquard-api/src/tech_tokimeki/takibi/spark.rs
+++ b/crates/jacquard-api/src/tech_tokimeki/takibi/spark.rs
@@ -137,37 +137,37 @@ pub mod spark_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Text;
         type CreatedAt;
+        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Text = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
-        type Text = Set<members::text>;
-        type CreatedAt = St::CreatedAt;
+        type Text = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Text = St::Text;
         type CreatedAt = Set<members::created_at>;
+        type Text = St::Text;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type CreatedAt = St::CreatedAt;
+        type Text = Set<members::text>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `text` field
-        pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `text` field
+        pub struct text(());
     }
 }
 
@@ -237,8 +237,8 @@ where
 impl<S: BosStr, St> SparkBuilder<S, St>
 where
     St: spark_state::State,
-    St::Text: spark_state::IsSet,
     St::CreatedAt: spark_state::IsSet,
+    St::Text: spark_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Spark<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/communication.rs b/crates/jacquard-api/src/tools_ozone/communication.rs
index eedc5ec5..96ecddf3 100644
--- a/crates/jacquard-api/src/tools_ozone/communication.rs
+++ b/crates/jacquard-api/src/tools_ozone/communication.rs
@@ -79,127 +79,127 @@ pub mod template_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type LastUpdatedBy;
+        type CreatedAt;
         type Disabled;
+        type Id;
         type UpdatedAt;
-        type CreatedAt;
-        type LastUpdatedBy;
         type ContentMarkdown;
         type Name;
-        type Id;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type LastUpdatedBy = Unset;
+        type CreatedAt = Unset;
         type Disabled = Unset;
+        type Id = Unset;
         type UpdatedAt = Unset;
-        type CreatedAt = Unset;
-        type LastUpdatedBy = Unset;
         type ContentMarkdown = Unset;
         type Name = Unset;
-        type Id = Unset;
     }
-    ///State transition - sets the `disabled` field to Set
-    pub struct SetDisabled<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDisabled<St> {}
-    impl<St: State> State for SetDisabled<St> {
-        type Disabled = Set<members::disabled>;
-        type UpdatedAt = St::UpdatedAt;
+    ///State transition - sets the `last_updated_by` field to Set
+    pub struct SetLastUpdatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLastUpdatedBy<St> {}
+    impl<St: State> State for SetLastUpdatedBy<St> {
+        type LastUpdatedBy = Set<members::last_updated_by>;
         type CreatedAt = St::CreatedAt;
-        type LastUpdatedBy = St::LastUpdatedBy;
-        type ContentMarkdown = St::ContentMarkdown;
-        type Name = St::Name;
-        type Id = St::Id;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
         type Disabled = St::Disabled;
-        type UpdatedAt = Set<members::updated_at>;
-        type CreatedAt = St::CreatedAt;
-        type LastUpdatedBy = St::LastUpdatedBy;
+        type Id = St::Id;
+        type UpdatedAt = St::UpdatedAt;
         type ContentMarkdown = St::ContentMarkdown;
         type Name = St::Name;
-        type Id = St::Id;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
+        type LastUpdatedBy = St::LastUpdatedBy;
+        type CreatedAt = Set<members::created_at>;
         type Disabled = St::Disabled;
+        type Id = St::Id;
         type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = Set<members::created_at>;
-        type LastUpdatedBy = St::LastUpdatedBy;
         type ContentMarkdown = St::ContentMarkdown;
         type Name = St::Name;
+    }
+    ///State transition - sets the `disabled` field to Set
+    pub struct SetDisabled<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDisabled<St> {}
+    impl<St: State> State for SetDisabled<St> {
+        type LastUpdatedBy = St::LastUpdatedBy;
+        type CreatedAt = St::CreatedAt;
+        type Disabled = Set<members::disabled>;
         type Id = St::Id;
+        type UpdatedAt = St::UpdatedAt;
+        type ContentMarkdown = St::ContentMarkdown;
+        type Name = St::Name;
     }
-    ///State transition - sets the `last_updated_by` field to Set
-    pub struct SetLastUpdatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLastUpdatedBy<St> {}
-    impl<St: State> State for SetLastUpdatedBy<St> {
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type LastUpdatedBy = St::LastUpdatedBy;
+        type CreatedAt = St::CreatedAt;
         type Disabled = St::Disabled;
+        type Id = Set<members::id>;
         type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
-        type LastUpdatedBy = Set<members::last_updated_by>;
         type ContentMarkdown = St::ContentMarkdown;
         type Name = St::Name;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type LastUpdatedBy = St::LastUpdatedBy;
+        type CreatedAt = St::CreatedAt;
+        type Disabled = St::Disabled;
         type Id = St::Id;
+        type UpdatedAt = Set<members::updated_at>;
+        type ContentMarkdown = St::ContentMarkdown;
+        type Name = St::Name;
     }
     ///State transition - sets the `content_markdown` field to Set
     pub struct SetContentMarkdown<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContentMarkdown<St> {}
     impl<St: State> State for SetContentMarkdown<St> {
+        type LastUpdatedBy = St::LastUpdatedBy;
+        type CreatedAt = St::CreatedAt;
         type Disabled = St::Disabled;
+        type Id = St::Id;
         type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
-        type LastUpdatedBy = St::LastUpdatedBy;
         type ContentMarkdown = Set<members::content_markdown>;
         type Name = St::Name;
-        type Id = St::Id;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Disabled = St::Disabled;
-        type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type ContentMarkdown = St::ContentMarkdown;
-        type Name = Set<members::name>;
-        type Id = St::Id;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
+        type CreatedAt = St::CreatedAt;
         type Disabled = St::Disabled;
+        type Id = St::Id;
         type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
-        type LastUpdatedBy = St::LastUpdatedBy;
         type ContentMarkdown = St::ContentMarkdown;
-        type Name = St::Name;
-        type Id = Set<members::id>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `last_updated_by` field
+        pub struct last_updated_by(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `disabled` field
         pub struct disabled(());
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `last_updated_by` field
-        pub struct last_updated_by(());
         ///Marker type for the `content_markdown` field
         pub struct content_markdown(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `id` field
-        pub struct id(());
     }
 }
 
@@ -400,13 +400,13 @@ where
 impl<S: BosStr, St> TemplateViewBuilder<S, St>
 where
     St: template_view_state::State,
+    St::LastUpdatedBy: template_view_state::IsSet,
+    St::CreatedAt: template_view_state::IsSet,
     St::Disabled: template_view_state::IsSet,
+    St::Id: template_view_state::IsSet,
     St::UpdatedAt: template_view_state::IsSet,
-    St::CreatedAt: template_view_state::IsSet,
-    St::LastUpdatedBy: template_view_state::IsSet,
     St::ContentMarkdown: template_view_state::IsSet,
     St::Name: template_view_state::IsSet,
-    St::Id: template_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> TemplateView<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/moderation.rs b/crates/jacquard-api/src/tools_ozone/moderation.rs
index 92617017..bf6d6789 100644
--- a/crates/jacquard-api/src/tools_ozone/moderation.rs
+++ b/crates/jacquard-api/src/tools_ozone/moderation.rs
@@ -5847,50 +5847,50 @@ pub mod age_assurance_event_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type AttemptId;
         type Status;
+        type AttemptId;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type AttemptId = Unset;
         type Status = Unset;
+        type AttemptId = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type AttemptId = St::AttemptId;
-        type Status = St::Status;
-    }
-    ///State transition - sets the `attempt_id` field to Set
-    pub struct SetAttemptId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAttemptId<St> {}
-    impl<St: State> State for SetAttemptId<St> {
-        type CreatedAt = St::CreatedAt;
-        type AttemptId = Set<members::attempt_id>;
         type Status = St::Status;
+        type AttemptId = St::AttemptId;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
         type CreatedAt = St::CreatedAt;
-        type AttemptId = St::AttemptId;
         type Status = Set<members::status>;
+        type AttemptId = St::AttemptId;
+    }
+    ///State transition - sets the `attempt_id` field to Set
+    pub struct SetAttemptId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAttemptId<St> {}
+    impl<St: State> State for SetAttemptId<St> {
+        type CreatedAt = St::CreatedAt;
+        type Status = St::Status;
+        type AttemptId = Set<members::attempt_id>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `attempt_id` field
-        pub struct attempt_id(());
         ///Marker type for the `status` field
         pub struct status(());
+        ///Marker type for the `attempt_id` field
+        pub struct attempt_id(());
     }
 }
 
@@ -6082,8 +6082,8 @@ impl<S: BosStr, St> AgeAssuranceEventBuilder<S, St>
 where
     St: age_assurance_event_state::State,
     St::CreatedAt: age_assurance_event_state::IsSet,
-    St::AttemptId: age_assurance_event_state::IsSet,
     St::Status: age_assurance_event_state::IsSet,
+    St::AttemptId: age_assurance_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AgeAssuranceEvent<S> {
@@ -6132,67 +6132,67 @@ pub mod blob_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type MimeType;
         type Size;
         type CreatedAt;
         type Cid;
+        type MimeType;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type MimeType = Unset;
         type Size = Unset;
         type CreatedAt = Unset;
         type Cid = Unset;
-    }
-    ///State transition - sets the `mime_type` field to Set
-    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMimeType<St> {}
-    impl<St: State> State for SetMimeType<St> {
-        type MimeType = Set<members::mime_type>;
-        type Size = St::Size;
-        type CreatedAt = St::CreatedAt;
-        type Cid = St::Cid;
+        type MimeType = Unset;
     }
     ///State transition - sets the `size` field to Set
     pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSize<St> {}
     impl<St: State> State for SetSize<St> {
-        type MimeType = St::MimeType;
         type Size = Set<members::size>;
         type CreatedAt = St::CreatedAt;
         type Cid = St::Cid;
+        type MimeType = St::MimeType;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type MimeType = St::MimeType;
         type Size = St::Size;
         type CreatedAt = Set<members::created_at>;
         type Cid = St::Cid;
+        type MimeType = St::MimeType;
     }
     ///State transition - sets the `cid` field to Set
     pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCid<St> {}
     impl<St: State> State for SetCid<St> {
-        type MimeType = St::MimeType;
         type Size = St::Size;
         type CreatedAt = St::CreatedAt;
         type Cid = Set<members::cid>;
+        type MimeType = St::MimeType;
+    }
+    ///State transition - sets the `mime_type` field to Set
+    pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMimeType<St> {}
+    impl<St: State> State for SetMimeType<St> {
+        type Size = St::Size;
+        type CreatedAt = St::CreatedAt;
+        type Cid = St::Cid;
+        type MimeType = Set<members::mime_type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `mime_type` field
-        pub struct mime_type(());
         ///Marker type for the `size` field
         pub struct size(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
         ///Marker type for the `cid` field
         pub struct cid(());
+        ///Marker type for the `mime_type` field
+        pub struct mime_type(());
     }
 }
 
@@ -6336,10 +6336,10 @@ where
 impl<S: BosStr, St> BlobViewBuilder<S, St>
 where
     St: blob_view_state::State,
-    St::MimeType: blob_view_state::IsSet,
     St::Size: blob_view_state::IsSet,
     St::CreatedAt: blob_view_state::IsSet,
     St::Cid: blob_view_state::IsSet,
+    St::MimeType: blob_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> BlobView<S> {
@@ -6543,37 +6543,37 @@ pub mod image_details_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Height;
         type Width;
+        type Height;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Height = Unset;
         type Width = Unset;
-    }
-    ///State transition - sets the `height` field to Set
-    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetHeight<St> {}
-    impl<St: State> State for SetHeight<St> {
-        type Height = Set<members::height>;
-        type Width = St::Width;
+        type Height = Unset;
     }
     ///State transition - sets the `width` field to Set
     pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidth<St> {}
     impl<St: State> State for SetWidth<St> {
-        type Height = St::Height;
         type Width = Set<members::width>;
+        type Height = St::Height;
+    }
+    ///State transition - sets the `height` field to Set
+    pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetHeight<St> {}
+    impl<St: State> State for SetHeight<St> {
+        type Width = St::Width;
+        type Height = Set<members::height>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `height` field
-        pub struct height(());
         ///Marker type for the `width` field
         pub struct width(());
+        ///Marker type for the `height` field
+        pub struct height(());
     }
 }
 
@@ -6643,8 +6643,8 @@ where
 impl<S: BosStr, St> ImageDetailsBuilder<S, St>
 where
     St: image_details_state::State,
-    St::Height: image_details_state::IsSet,
     St::Width: image_details_state::IsSet,
+    St::Height: image_details_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ImageDetails<S> {
@@ -6677,37 +6677,37 @@ pub mod mod_event_label_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreateLabelVals;
         type NegateLabelVals;
+        type CreateLabelVals;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreateLabelVals = Unset;
         type NegateLabelVals = Unset;
-    }
-    ///State transition - sets the `create_label_vals` field to Set
-    pub struct SetCreateLabelVals<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreateLabelVals<St> {}
-    impl<St: State> State for SetCreateLabelVals<St> {
-        type CreateLabelVals = Set<members::create_label_vals>;
-        type NegateLabelVals = St::NegateLabelVals;
+        type CreateLabelVals = Unset;
     }
     ///State transition - sets the `negate_label_vals` field to Set
     pub struct SetNegateLabelVals<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetNegateLabelVals<St> {}
     impl<St: State> State for SetNegateLabelVals<St> {
-        type CreateLabelVals = St::CreateLabelVals;
         type NegateLabelVals = Set<members::negate_label_vals>;
+        type CreateLabelVals = St::CreateLabelVals;
+    }
+    ///State transition - sets the `create_label_vals` field to Set
+    pub struct SetCreateLabelVals<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreateLabelVals<St> {}
+    impl<St: State> State for SetCreateLabelVals<St> {
+        type NegateLabelVals = St::NegateLabelVals;
+        type CreateLabelVals = Set<members::create_label_vals>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `create_label_vals` field
-        pub struct create_label_vals(());
         ///Marker type for the `negate_label_vals` field
         pub struct negate_label_vals(());
+        ///Marker type for the `create_label_vals` field
+        pub struct create_label_vals(());
     }
 }
 
@@ -6803,8 +6803,8 @@ where
 impl<S: BosStr, St> ModEventLabelBuilder<S, St>
 where
     St: mod_event_label_state::State,
-    St::CreateLabelVals: mod_event_label_state::IsSet,
     St::NegateLabelVals: mod_event_label_state::IsSet,
+    St::CreateLabelVals: mod_event_label_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ModEventLabel<S> {
@@ -7359,105 +7359,105 @@ pub mod mod_event_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type SubjectBlobCids;
+        type Id;
         type Subject;
-        type CreatedAt;
-        type Event;
         type CreatedBy;
-        type Id;
+        type Event;
+        type SubjectBlobCids;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type SubjectBlobCids = Unset;
+        type Id = Unset;
         type Subject = Unset;
-        type CreatedAt = Unset;
-        type Event = Unset;
         type CreatedBy = Unset;
-        type Id = Unset;
+        type Event = Unset;
+        type SubjectBlobCids = Unset;
+        type CreatedAt = Unset;
     }
-    ///State transition - sets the `subject_blob_cids` field to Set
-    pub struct SetSubjectBlobCids<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubjectBlobCids<St> {}
-    impl<St: State> State for SetSubjectBlobCids<St> {
-        type SubjectBlobCids = Set<members::subject_blob_cids>;
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
-        type Event = St::Event;
         type CreatedBy = St::CreatedBy;
-        type Id = St::Id;
+        type Event = St::Event;
+        type SubjectBlobCids = St::SubjectBlobCids;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type SubjectBlobCids = St::SubjectBlobCids;
+        type Id = St::Id;
         type Subject = Set<members::subject>;
-        type CreatedAt = St::CreatedAt;
-        type Event = St::Event;
         type CreatedBy = St::CreatedBy;
-        type Id = St::Id;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type Event = St::Event;
         type SubjectBlobCids = St::SubjectBlobCids;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_by` field to Set
+    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
+    impl<St: State> State for SetCreatedBy<St> {
+        type Id = St::Id;
         type Subject = St::Subject;
-        type CreatedAt = Set<members::created_at>;
+        type CreatedBy = Set<members::created_by>;
         type Event = St::Event;
-        type CreatedBy = St::CreatedBy;
-        type Id = St::Id;
+        type SubjectBlobCids = St::SubjectBlobCids;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `event` field to Set
     pub struct SetEvent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvent<St> {}
     impl<St: State> State for SetEvent<St> {
-        type SubjectBlobCids = St::SubjectBlobCids;
+        type Id = St::Id;
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
-        type Event = Set<members::event>;
         type CreatedBy = St::CreatedBy;
-        type Id = St::Id;
-    }
-    ///State transition - sets the `created_by` field to Set
-    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
-    impl<St: State> State for SetCreatedBy<St> {
+        type Event = Set<members::event>;
         type SubjectBlobCids = St::SubjectBlobCids;
-        type Subject = St::Subject;
         type CreatedAt = St::CreatedAt;
-        type Event = St::Event;
-        type CreatedBy = Set<members::created_by>;
-        type Id = St::Id;
     }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type SubjectBlobCids = St::SubjectBlobCids;
+    ///State transition - sets the `subject_blob_cids` field to Set
+    pub struct SetSubjectBlobCids<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubjectBlobCids<St> {}
+    impl<St: State> State for SetSubjectBlobCids<St> {
+        type Id = St::Id;
         type Subject = St::Subject;
-        type CreatedAt = St::CreatedAt;
+        type CreatedBy = St::CreatedBy;
         type Event = St::Event;
+        type SubjectBlobCids = Set<members::subject_blob_cids>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Id = St::Id;
+        type Subject = St::Subject;
         type CreatedBy = St::CreatedBy;
-        type Id = Set<members::id>;
+        type Event = St::Event;
+        type SubjectBlobCids = St::SubjectBlobCids;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject_blob_cids` field
-        pub struct subject_blob_cids(());
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
-        ///Marker type for the `event` field
-        pub struct event(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
-        ///Marker type for the `id` field
-        pub struct id(());
+        ///Marker type for the `event` field
+        pub struct event(());
+        ///Marker type for the `subject_blob_cids` field
+        pub struct subject_blob_cids(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -7652,12 +7652,12 @@ impl<S: BosStr, St: mod_event_view_state::State> ModEventViewBuilder<S, St> {
 impl<S: BosStr, St> ModEventViewBuilder<S, St>
 where
     St: mod_event_view_state::State,
-    St::SubjectBlobCids: mod_event_view_state::IsSet,
+    St::Id: mod_event_view_state::IsSet,
     St::Subject: mod_event_view_state::IsSet,
-    St::CreatedAt: mod_event_view_state::IsSet,
-    St::Event: mod_event_view_state::IsSet,
     St::CreatedBy: mod_event_view_state::IsSet,
-    St::Id: mod_event_view_state::IsSet,
+    St::Event: mod_event_view_state::IsSet,
+    St::SubjectBlobCids: mod_event_view_state::IsSet,
+    St::CreatedAt: mod_event_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ModEventView<S> {
@@ -7704,103 +7704,103 @@ pub mod mod_event_view_detail_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
+        type Subject;
         type Id;
-        type SubjectBlobs;
         type CreatedBy;
-        type Subject;
+        type SubjectBlobs;
+        type CreatedAt;
         type Event;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
+        type Subject = Unset;
         type Id = Unset;
-        type SubjectBlobs = Unset;
         type CreatedBy = Unset;
-        type Subject = Unset;
+        type SubjectBlobs = Unset;
+        type CreatedAt = Unset;
         type Event = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Id = St::Id;
-        type SubjectBlobs = St::SubjectBlobs;
-        type CreatedBy = St::CreatedBy;
-        type Subject = St::Subject;
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Subject = Set<members::subject>;
+        type Id = St::Id;
+        type CreatedBy = St::CreatedBy;
+        type SubjectBlobs = St::SubjectBlobs;
+        type CreatedAt = St::CreatedAt;
         type Event = St::Event;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
         type Id = Set<members::id>;
-        type SubjectBlobs = St::SubjectBlobs;
         type CreatedBy = St::CreatedBy;
-        type Subject = St::Subject;
-        type Event = St::Event;
-    }
-    ///State transition - sets the `subject_blobs` field to Set
-    pub struct SetSubjectBlobs<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubjectBlobs<St> {}
-    impl<St: State> State for SetSubjectBlobs<St> {
+        type SubjectBlobs = St::SubjectBlobs;
         type CreatedAt = St::CreatedAt;
-        type Id = St::Id;
-        type SubjectBlobs = Set<members::subject_blobs>;
-        type CreatedBy = St::CreatedBy;
-        type Subject = St::Subject;
         type Event = St::Event;
     }
     ///State transition - sets the `created_by` field to Set
     pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
     impl<St: State> State for SetCreatedBy<St> {
-        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
         type Id = St::Id;
-        type SubjectBlobs = St::SubjectBlobs;
         type CreatedBy = Set<members::created_by>;
-        type Subject = St::Subject;
+        type SubjectBlobs = St::SubjectBlobs;
+        type CreatedAt = St::CreatedAt;
         type Event = St::Event;
     }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
+    ///State transition - sets the `subject_blobs` field to Set
+    pub struct SetSubjectBlobs<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubjectBlobs<St> {}
+    impl<St: State> State for SetSubjectBlobs<St> {
+        type Subject = St::Subject;
+        type Id = St::Id;
+        type CreatedBy = St::CreatedBy;
+        type SubjectBlobs = Set<members::subject_blobs>;
         type CreatedAt = St::CreatedAt;
+        type Event = St::Event;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Subject = St::Subject;
         type Id = St::Id;
-        type SubjectBlobs = St::SubjectBlobs;
         type CreatedBy = St::CreatedBy;
-        type Subject = Set<members::subject>;
+        type SubjectBlobs = St::SubjectBlobs;
+        type CreatedAt = Set<members::created_at>;
         type Event = St::Event;
     }
     ///State transition - sets the `event` field to Set
     pub struct SetEvent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvent<St> {}
     impl<St: State> State for SetEvent<St> {
-        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
         type Id = St::Id;
-        type SubjectBlobs = St::SubjectBlobs;
         type CreatedBy = St::CreatedBy;
-        type Subject = St::Subject;
+        type SubjectBlobs = St::SubjectBlobs;
+        type CreatedAt = St::CreatedAt;
         type Event = Set<members::event>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `subject_blobs` field
-        pub struct subject_blobs(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
+        ///Marker type for the `subject_blobs` field
+        pub struct subject_blobs(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `event` field
         pub struct event(());
     }
@@ -7972,11 +7972,11 @@ where
 impl<S: BosStr, St> ModEventViewDetailBuilder<S, St>
 where
     St: mod_event_view_detail_state::State,
-    St::CreatedAt: mod_event_view_detail_state::IsSet,
+    St::Subject: mod_event_view_detail_state::IsSet,
     St::Id: mod_event_view_detail_state::IsSet,
-    St::SubjectBlobs: mod_event_view_detail_state::IsSet,
     St::CreatedBy: mod_event_view_detail_state::IsSet,
-    St::Subject: mod_event_view_detail_state::IsSet,
+    St::SubjectBlobs: mod_event_view_detail_state::IsSet,
+    St::CreatedAt: mod_event_view_detail_state::IsSet,
     St::Event: mod_event_view_detail_state::IsSet,
 {
     /// Build the final struct.
@@ -8020,37 +8020,37 @@ pub mod record_event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Timestamp;
         type Op;
+        type Timestamp;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Timestamp = Unset;
         type Op = Unset;
-    }
-    ///State transition - sets the `timestamp` field to Set
-    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
-    impl<St: State> State for SetTimestamp<St> {
-        type Timestamp = Set<members::timestamp>;
-        type Op = St::Op;
+        type Timestamp = Unset;
     }
     ///State transition - sets the `op` field to Set
     pub struct SetOp<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOp<St> {}
     impl<St: State> State for SetOp<St> {
-        type Timestamp = St::Timestamp;
         type Op = Set<members::op>;
+        type Timestamp = St::Timestamp;
+    }
+    ///State transition - sets the `timestamp` field to Set
+    pub struct SetTimestamp<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTimestamp<St> {}
+    impl<St: State> State for SetTimestamp<St> {
+        type Op = St::Op;
+        type Timestamp = Set<members::timestamp>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `timestamp` field
-        pub struct timestamp(());
         ///Marker type for the `op` field
         pub struct op(());
+        ///Marker type for the `timestamp` field
+        pub struct timestamp(());
     }
 }
 
@@ -8146,8 +8146,8 @@ where
 impl<S: BosStr, St> RecordEventBuilder<S, St>
 where
     St: record_event_state::State,
-    St::Timestamp: record_event_state::IsSet,
     St::Op: record_event_state::IsSet,
+    St::Timestamp: record_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RecordEvent<S> {
@@ -8184,127 +8184,127 @@ pub mod record_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Uri;
+        type BlobCids;
+        type Value;
         type IndexedAt;
-        type Cid;
         type Moderation;
-        type Value;
-        type Uri;
         type Repo;
-        type BlobCids;
+        type Cid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Uri = Unset;
+        type BlobCids = Unset;
+        type Value = Unset;
         type IndexedAt = Unset;
-        type Cid = Unset;
         type Moderation = Unset;
-        type Value = Unset;
-        type Uri = Unset;
         type Repo = Unset;
-        type BlobCids = Unset;
+        type Cid = Unset;
     }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type IndexedAt = Set<members::indexed_at>;
-        type Cid = St::Cid;
-        type Moderation = St::Moderation;
-        type Value = St::Value;
-        type Uri = St::Uri;
-        type Repo = St::Repo;
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Uri = Set<members::uri>;
         type BlobCids = St::BlobCids;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+        type Value = St::Value;
         type IndexedAt = St::IndexedAt;
-        type Cid = Set<members::cid>;
         type Moderation = St::Moderation;
-        type Value = St::Value;
-        type Uri = St::Uri;
         type Repo = St::Repo;
-        type BlobCids = St::BlobCids;
-    }
-    ///State transition - sets the `moderation` field to Set
-    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetModeration<St> {}
-    impl<St: State> State for SetModeration<St> {
-        type IndexedAt = St::IndexedAt;
         type Cid = St::Cid;
-        type Moderation = Set<members::moderation>;
-        type Value = St::Value;
+    }
+    ///State transition - sets the `blob_cids` field to Set
+    pub struct SetBlobCids<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetBlobCids<St> {}
+    impl<St: State> State for SetBlobCids<St> {
         type Uri = St::Uri;
+        type BlobCids = Set<members::blob_cids>;
+        type Value = St::Value;
+        type IndexedAt = St::IndexedAt;
+        type Moderation = St::Moderation;
         type Repo = St::Repo;
-        type BlobCids = St::BlobCids;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
-        type Moderation = St::Moderation;
-        type Value = Set<members::value>;
         type Uri = St::Uri;
-        type Repo = St::Repo;
         type BlobCids = St::BlobCids;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
+        type Value = Set<members::value>;
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Moderation = St::Moderation;
+        type Repo = St::Repo;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Uri = St::Uri;
+        type BlobCids = St::BlobCids;
         type Value = St::Value;
-        type Uri = Set<members::uri>;
+        type IndexedAt = Set<members::indexed_at>;
+        type Moderation = St::Moderation;
         type Repo = St::Repo;
+        type Cid = St::Cid;
+    }
+    ///State transition - sets the `moderation` field to Set
+    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetModeration<St> {}
+    impl<St: State> State for SetModeration<St> {
+        type Uri = St::Uri;
         type BlobCids = St::BlobCids;
+        type Value = St::Value;
+        type IndexedAt = St::IndexedAt;
+        type Moderation = Set<members::moderation>;
+        type Repo = St::Repo;
+        type Cid = St::Cid;
     }
     ///State transition - sets the `repo` field to Set
     pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRepo<St> {}
     impl<St: State> State for SetRepo<St> {
+        type Uri = St::Uri;
+        type BlobCids = St::BlobCids;
+        type Value = St::Value;
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Moderation = St::Moderation;
-        type Value = St::Value;
-        type Uri = St::Uri;
         type Repo = Set<members::repo>;
-        type BlobCids = St::BlobCids;
+        type Cid = St::Cid;
     }
-    ///State transition - sets the `blob_cids` field to Set
-    pub struct SetBlobCids<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetBlobCids<St> {}
-    impl<St: State> State for SetBlobCids<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type BlobCids = St::BlobCids;
+        type Value = St::Value;
         type IndexedAt = St::IndexedAt;
-        type Cid = St::Cid;
         type Moderation = St::Moderation;
-        type Value = St::Value;
-        type Uri = St::Uri;
         type Repo = St::Repo;
-        type BlobCids = Set<members::blob_cids>;
+        type Cid = Set<members::cid>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `uri` field
+        pub struct uri(());
+        ///Marker type for the `blob_cids` field
+        pub struct blob_cids(());
+        ///Marker type for the `value` field
+        pub struct value(());
         ///Marker type for the `indexed_at` field
         pub struct indexed_at(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `moderation` field
         pub struct moderation(());
-        ///Marker type for the `value` field
-        pub struct value(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
         ///Marker type for the `repo` field
         pub struct repo(());
-        ///Marker type for the `blob_cids` field
-        pub struct blob_cids(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
     }
 }
 
@@ -8477,13 +8477,13 @@ where
 impl<S: BosStr, St> RecordViewBuilder<S, St>
 where
     St: record_view_state::State,
+    St::Uri: record_view_state::IsSet,
+    St::BlobCids: record_view_state::IsSet,
+    St::Value: record_view_state::IsSet,
     St::IndexedAt: record_view_state::IsSet,
-    St::Cid: record_view_state::IsSet,
     St::Moderation: record_view_state::IsSet,
-    St::Value: record_view_state::IsSet,
-    St::Uri: record_view_state::IsSet,
     St::Repo: record_view_state::IsSet,
-    St::BlobCids: record_view_state::IsSet,
+    St::Cid: record_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RecordView<S> {
@@ -8526,125 +8526,125 @@ pub mod record_view_detail_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
         type Blobs;
-        type Repo;
-        type IndexedAt;
+        type Cid;
         type Moderation;
+        type IndexedAt;
+        type Repo;
         type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
         type Blobs = Unset;
-        type Repo = Unset;
-        type IndexedAt = Unset;
+        type Cid = Unset;
         type Moderation = Unset;
+        type IndexedAt = Unset;
+        type Repo = Unset;
         type Value = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
-        type Blobs = St::Blobs;
-        type Repo = St::Repo;
-        type IndexedAt = St::IndexedAt;
-        type Moderation = St::Moderation;
-        type Value = St::Value;
-    }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
         type Blobs = St::Blobs;
-        type Repo = St::Repo;
-        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
         type Moderation = St::Moderation;
+        type IndexedAt = St::IndexedAt;
+        type Repo = St::Repo;
         type Value = St::Value;
     }
     ///State transition - sets the `blobs` field to Set
     pub struct SetBlobs<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetBlobs<St> {}
     impl<St: State> State for SetBlobs<St> {
-        type Cid = St::Cid;
         type Uri = St::Uri;
         type Blobs = Set<members::blobs>;
-        type Repo = St::Repo;
+        type Cid = St::Cid;
+        type Moderation = St::Moderation;
         type IndexedAt = St::IndexedAt;
+        type Repo = St::Repo;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Blobs = St::Blobs;
+        type Cid = Set<members::cid>;
         type Moderation = St::Moderation;
+        type IndexedAt = St::IndexedAt;
+        type Repo = St::Repo;
         type Value = St::Value;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
-        type Cid = St::Cid;
+    ///State transition - sets the `moderation` field to Set
+    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetModeration<St> {}
+    impl<St: State> State for SetModeration<St> {
         type Uri = St::Uri;
         type Blobs = St::Blobs;
-        type Repo = Set<members::repo>;
+        type Cid = St::Cid;
+        type Moderation = Set<members::moderation>;
         type IndexedAt = St::IndexedAt;
-        type Moderation = St::Moderation;
+        type Repo = St::Repo;
         type Value = St::Value;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
-        type Cid = St::Cid;
         type Uri = St::Uri;
         type Blobs = St::Blobs;
-        type Repo = St::Repo;
-        type IndexedAt = Set<members::indexed_at>;
+        type Cid = St::Cid;
         type Moderation = St::Moderation;
+        type IndexedAt = Set<members::indexed_at>;
+        type Repo = St::Repo;
         type Value = St::Value;
     }
-    ///State transition - sets the `moderation` field to Set
-    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetModeration<St> {}
-    impl<St: State> State for SetModeration<St> {
-        type Cid = St::Cid;
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
         type Uri = St::Uri;
         type Blobs = St::Blobs;
-        type Repo = St::Repo;
+        type Cid = St::Cid;
+        type Moderation = St::Moderation;
         type IndexedAt = St::IndexedAt;
-        type Moderation = Set<members::moderation>;
+        type Repo = Set<members::repo>;
         type Value = St::Value;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Cid = St::Cid;
         type Uri = St::Uri;
         type Blobs = St::Blobs;
-        type Repo = St::Repo;
-        type IndexedAt = St::IndexedAt;
+        type Cid = St::Cid;
         type Moderation = St::Moderation;
+        type IndexedAt = St::IndexedAt;
+        type Repo = St::Repo;
         type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `blobs` field
         pub struct blobs(());
-        ///Marker type for the `repo` field
-        pub struct repo(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `moderation` field
         pub struct moderation(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
+        ///Marker type for the `repo` field
+        pub struct repo(());
         ///Marker type for the `value` field
         pub struct value(());
     }
@@ -8833,12 +8833,12 @@ where
 impl<S: BosStr, St> RecordViewDetailBuilder<S, St>
 where
     St: record_view_detail_state::State,
-    St::Cid: record_view_detail_state::IsSet,
     St::Uri: record_view_detail_state::IsSet,
     St::Blobs: record_view_detail_state::IsSet,
-    St::Repo: record_view_detail_state::IsSet,
-    St::IndexedAt: record_view_detail_state::IsSet,
+    St::Cid: record_view_detail_state::IsSet,
     St::Moderation: record_view_detail_state::IsSet,
+    St::IndexedAt: record_view_detail_state::IsSet,
+    St::Repo: record_view_detail_state::IsSet,
     St::Value: record_view_detail_state::IsSet,
 {
     /// Build the final struct.
@@ -8984,85 +8984,85 @@ pub mod repo_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Moderation;
-        type IndexedAt;
-        type Did;
         type Handle;
         type RelatedRecords;
+        type Did;
+        type IndexedAt;
+        type Moderation;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Moderation = Unset;
-        type IndexedAt = Unset;
-        type Did = Unset;
         type Handle = Unset;
-        type RelatedRecords = Unset;
-    }
-    ///State transition - sets the `moderation` field to Set
-    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetModeration<St> {}
-    impl<St: State> State for SetModeration<St> {
-        type Moderation = Set<members::moderation>;
-        type IndexedAt = St::IndexedAt;
-        type Did = St::Did;
-        type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
-    }
-    ///State transition - sets the `indexed_at` field to Set
-    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
-    impl<St: State> State for SetIndexedAt<St> {
-        type Moderation = St::Moderation;
-        type IndexedAt = Set<members::indexed_at>;
-        type Did = St::Did;
-        type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Moderation = St::Moderation;
-        type IndexedAt = St::IndexedAt;
-        type Did = Set<members::did>;
-        type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
+        type RelatedRecords = Unset;
+        type Did = Unset;
+        type IndexedAt = Unset;
+        type Moderation = Unset;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Moderation = St::Moderation;
-        type IndexedAt = St::IndexedAt;
-        type Did = St::Did;
         type Handle = Set<members::handle>;
         type RelatedRecords = St::RelatedRecords;
+        type Did = St::Did;
+        type IndexedAt = St::IndexedAt;
+        type Moderation = St::Moderation;
     }
     ///State transition - sets the `related_records` field to Set
     pub struct SetRelatedRecords<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRelatedRecords<St> {}
     impl<St: State> State for SetRelatedRecords<St> {
+        type Handle = St::Handle;
+        type RelatedRecords = Set<members::related_records>;
+        type Did = St::Did;
+        type IndexedAt = St::IndexedAt;
         type Moderation = St::Moderation;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Handle = St::Handle;
+        type RelatedRecords = St::RelatedRecords;
+        type Did = Set<members::did>;
         type IndexedAt = St::IndexedAt;
+        type Moderation = St::Moderation;
+    }
+    ///State transition - sets the `indexed_at` field to Set
+    pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
+    impl<St: State> State for SetIndexedAt<St> {
+        type Handle = St::Handle;
+        type RelatedRecords = St::RelatedRecords;
         type Did = St::Did;
+        type IndexedAt = Set<members::indexed_at>;
+        type Moderation = St::Moderation;
+    }
+    ///State transition - sets the `moderation` field to Set
+    pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetModeration<St> {}
+    impl<St: State> State for SetModeration<St> {
         type Handle = St::Handle;
-        type RelatedRecords = Set<members::related_records>;
+        type RelatedRecords = St::RelatedRecords;
+        type Did = St::Did;
+        type IndexedAt = St::IndexedAt;
+        type Moderation = Set<members::moderation>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `moderation` field
-        pub struct moderation(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `handle` field
         pub struct handle(());
         ///Marker type for the `related_records` field
         pub struct related_records(());
+        ///Marker type for the `did` field
+        pub struct did(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
+        ///Marker type for the `moderation` field
+        pub struct moderation(());
     }
 }
 
@@ -9285,11 +9285,11 @@ impl<S: BosStr, St: repo_view_state::State> RepoViewBuilder<S, St> {
 impl<S: BosStr, St> RepoViewBuilder<S, St>
 where
     St: repo_view_state::State,
-    St::Moderation: repo_view_state::IsSet,
-    St::IndexedAt: repo_view_state::IsSet,
-    St::Did: repo_view_state::IsSet,
     St::Handle: repo_view_state::IsSet,
     St::RelatedRecords: repo_view_state::IsSet,
+    St::Did: repo_view_state::IsSet,
+    St::IndexedAt: repo_view_state::IsSet,
+    St::Moderation: repo_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RepoView<S> {
@@ -9338,84 +9338,84 @@ pub mod repo_view_detail_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Handle;
-        type RelatedRecords;
         type Moderation;
-        type IndexedAt;
         type Did;
+        type IndexedAt;
+        type RelatedRecords;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Handle = Unset;
-        type RelatedRecords = Unset;
         type Moderation = Unset;
-        type IndexedAt = Unset;
         type Did = Unset;
+        type IndexedAt = Unset;
+        type RelatedRecords = Unset;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
         type Handle = Set<members::handle>;
-        type RelatedRecords = St::RelatedRecords;
         type Moderation = St::Moderation;
-        type IndexedAt = St::IndexedAt;
         type Did = St::Did;
-    }
-    ///State transition - sets the `related_records` field to Set
-    pub struct SetRelatedRecords<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRelatedRecords<St> {}
-    impl<St: State> State for SetRelatedRecords<St> {
-        type Handle = St::Handle;
-        type RelatedRecords = Set<members::related_records>;
-        type Moderation = St::Moderation;
         type IndexedAt = St::IndexedAt;
-        type Did = St::Did;
+        type RelatedRecords = St::RelatedRecords;
     }
     ///State transition - sets the `moderation` field to Set
     pub struct SetModeration<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetModeration<St> {}
     impl<St: State> State for SetModeration<St> {
         type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
         type Moderation = Set<members::moderation>;
-        type IndexedAt = St::IndexedAt;
         type Did = St::Did;
+        type IndexedAt = St::IndexedAt;
+        type RelatedRecords = St::RelatedRecords;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Handle = St::Handle;
+        type Moderation = St::Moderation;
+        type Did = Set<members::did>;
+        type IndexedAt = St::IndexedAt;
+        type RelatedRecords = St::RelatedRecords;
     }
     ///State transition - sets the `indexed_at` field to Set
     pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetIndexedAt<St> {}
     impl<St: State> State for SetIndexedAt<St> {
         type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
         type Moderation = St::Moderation;
-        type IndexedAt = Set<members::indexed_at>;
         type Did = St::Did;
+        type IndexedAt = Set<members::indexed_at>;
+        type RelatedRecords = St::RelatedRecords;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
+    ///State transition - sets the `related_records` field to Set
+    pub struct SetRelatedRecords<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRelatedRecords<St> {}
+    impl<St: State> State for SetRelatedRecords<St> {
         type Handle = St::Handle;
-        type RelatedRecords = St::RelatedRecords;
         type Moderation = St::Moderation;
+        type Did = St::Did;
         type IndexedAt = St::IndexedAt;
-        type Did = Set<members::did>;
+        type RelatedRecords = Set<members::related_records>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `handle` field
         pub struct handle(());
-        ///Marker type for the `related_records` field
-        pub struct related_records(());
         ///Marker type for the `moderation` field
         pub struct moderation(());
-        ///Marker type for the `indexed_at` field
-        pub struct indexed_at(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `indexed_at` field
+        pub struct indexed_at(());
+        ///Marker type for the `related_records` field
+        pub struct related_records(());
     }
 }
 
@@ -9696,10 +9696,10 @@ impl<S: BosStr, St> RepoViewDetailBuilder<S, St>
 where
     St: repo_view_detail_state::State,
     St::Handle: repo_view_detail_state::IsSet,
-    St::RelatedRecords: repo_view_detail_state::IsSet,
     St::Moderation: repo_view_detail_state::IsSet,
-    St::IndexedAt: repo_view_detail_state::IsSet,
     St::Did: repo_view_detail_state::IsSet,
+    St::IndexedAt: repo_view_detail_state::IsSet,
+    St::RelatedRecords: repo_view_detail_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RepoViewDetail<S> {
@@ -9857,176 +9857,176 @@ pub mod reporter_stats_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Did;
-        type LabeledAccountCount;
+        type LabeledRecordCount;
         type ReportedRecordCount;
         type TakendownAccountCount;
-        type RecordReportCount;
-        type AccountReportCount;
         type TakendownRecordCount;
-        type LabeledRecordCount;
         type ReportedAccountCount;
+        type LabeledAccountCount;
+        type AccountReportCount;
+        type RecordReportCount;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Did = Unset;
-        type LabeledAccountCount = Unset;
+        type LabeledRecordCount = Unset;
         type ReportedRecordCount = Unset;
         type TakendownAccountCount = Unset;
-        type RecordReportCount = Unset;
-        type AccountReportCount = Unset;
         type TakendownRecordCount = Unset;
-        type LabeledRecordCount = Unset;
         type ReportedAccountCount = Unset;
+        type LabeledAccountCount = Unset;
+        type AccountReportCount = Unset;
+        type RecordReportCount = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
         type Did = Set<members::did>;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = St::RecordReportCount;
     }
-    ///State transition - sets the `labeled_account_count` field to Set
-    pub struct SetLabeledAccountCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLabeledAccountCount<St> {}
-    impl<St: State> State for SetLabeledAccountCount<St> {
+    ///State transition - sets the `labeled_record_count` field to Set
+    pub struct SetLabeledRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLabeledRecordCount<St> {}
+    impl<St: State> State for SetLabeledRecordCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = Set<members::labeled_account_count>;
+        type LabeledRecordCount = Set<members::labeled_record_count>;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = St::RecordReportCount;
     }
     ///State transition - sets the `reported_record_count` field to Set
     pub struct SetReportedRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReportedRecordCount<St> {}
     impl<St: State> State for SetReportedRecordCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = Set<members::reported_record_count>;
         type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = St::RecordReportCount;
     }
     ///State transition - sets the `takendown_account_count` field to Set
     pub struct SetTakendownAccountCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTakendownAccountCount<St> {}
     impl<St: State> State for SetTakendownAccountCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = Set<members::takendown_account_count>;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedAccountCount = St::ReportedAccountCount;
-    }
-    ///State transition - sets the `record_report_count` field to Set
-    pub struct SetRecordReportCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRecordReportCount<St> {}
-    impl<St: State> State for SetRecordReportCount<St> {
-        type Did = St::Did;
         type LabeledAccountCount = St::LabeledAccountCount;
-        type ReportedRecordCount = St::ReportedRecordCount;
-        type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = Set<members::record_report_count>;
         type AccountReportCount = St::AccountReportCount;
-        type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
-        type ReportedAccountCount = St::ReportedAccountCount;
-    }
-    ///State transition - sets the `account_report_count` field to Set
-    pub struct SetAccountReportCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAccountReportCount<St> {}
-    impl<St: State> State for SetAccountReportCount<St> {
-        type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
-        type ReportedRecordCount = St::ReportedRecordCount;
-        type TakendownAccountCount = St::TakendownAccountCount;
         type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = Set<members::account_report_count>;
-        type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
-        type ReportedAccountCount = St::ReportedAccountCount;
     }
     ///State transition - sets the `takendown_record_count` field to Set
     pub struct SetTakendownRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetTakendownRecordCount<St> {}
     impl<St: State> State for SetTakendownRecordCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = Set<members::takendown_record_count>;
-        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = St::RecordReportCount;
     }
-    ///State transition - sets the `labeled_record_count` field to Set
-    pub struct SetLabeledRecordCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLabeledRecordCount<St> {}
-    impl<St: State> State for SetLabeledRecordCount<St> {
+    ///State transition - sets the `reported_account_count` field to Set
+    pub struct SetReportedAccountCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReportedAccountCount<St> {}
+    impl<St: State> State for SetReportedAccountCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = St::TakendownAccountCount;
+        type TakendownRecordCount = St::TakendownRecordCount;
+        type ReportedAccountCount = Set<members::reported_account_count>;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
         type RecordReportCount = St::RecordReportCount;
+    }
+    ///State transition - sets the `labeled_account_count` field to Set
+    pub struct SetLabeledAccountCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLabeledAccountCount<St> {}
+    impl<St: State> State for SetLabeledAccountCount<St> {
+        type Did = St::Did;
+        type LabeledRecordCount = St::LabeledRecordCount;
+        type ReportedRecordCount = St::ReportedRecordCount;
+        type TakendownAccountCount = St::TakendownAccountCount;
+        type TakendownRecordCount = St::TakendownRecordCount;
+        type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = Set<members::labeled_account_count>;
         type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = St::RecordReportCount;
+    }
+    ///State transition - sets the `account_report_count` field to Set
+    pub struct SetAccountReportCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAccountReportCount<St> {}
+    impl<St: State> State for SetAccountReportCount<St> {
+        type Did = St::Did;
+        type LabeledRecordCount = St::LabeledRecordCount;
+        type ReportedRecordCount = St::ReportedRecordCount;
+        type TakendownAccountCount = St::TakendownAccountCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = Set<members::labeled_record_count>;
         type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = Set<members::account_report_count>;
+        type RecordReportCount = St::RecordReportCount;
     }
-    ///State transition - sets the `reported_account_count` field to Set
-    pub struct SetReportedAccountCount<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReportedAccountCount<St> {}
-    impl<St: State> State for SetReportedAccountCount<St> {
+    ///State transition - sets the `record_report_count` field to Set
+    pub struct SetRecordReportCount<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRecordReportCount<St> {}
+    impl<St: State> State for SetRecordReportCount<St> {
         type Did = St::Did;
-        type LabeledAccountCount = St::LabeledAccountCount;
+        type LabeledRecordCount = St::LabeledRecordCount;
         type ReportedRecordCount = St::ReportedRecordCount;
         type TakendownAccountCount = St::TakendownAccountCount;
-        type RecordReportCount = St::RecordReportCount;
-        type AccountReportCount = St::AccountReportCount;
         type TakendownRecordCount = St::TakendownRecordCount;
-        type LabeledRecordCount = St::LabeledRecordCount;
-        type ReportedAccountCount = Set<members::reported_account_count>;
+        type ReportedAccountCount = St::ReportedAccountCount;
+        type LabeledAccountCount = St::LabeledAccountCount;
+        type AccountReportCount = St::AccountReportCount;
+        type RecordReportCount = Set<members::record_report_count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `labeled_account_count` field
-        pub struct labeled_account_count(());
+        ///Marker type for the `labeled_record_count` field
+        pub struct labeled_record_count(());
         ///Marker type for the `reported_record_count` field
         pub struct reported_record_count(());
         ///Marker type for the `takendown_account_count` field
         pub struct takendown_account_count(());
-        ///Marker type for the `record_report_count` field
-        pub struct record_report_count(());
-        ///Marker type for the `account_report_count` field
-        pub struct account_report_count(());
         ///Marker type for the `takendown_record_count` field
         pub struct takendown_record_count(());
-        ///Marker type for the `labeled_record_count` field
-        pub struct labeled_record_count(());
         ///Marker type for the `reported_account_count` field
         pub struct reported_account_count(());
+        ///Marker type for the `labeled_account_count` field
+        pub struct labeled_account_count(());
+        ///Marker type for the `account_report_count` field
+        pub struct account_report_count(());
+        ///Marker type for the `record_report_count` field
+        pub struct record_report_count(());
     }
 }
 
@@ -10240,14 +10240,14 @@ impl<S: BosStr, St> ReporterStatsBuilder<S, St>
 where
     St: reporter_stats_state::State,
     St::Did: reporter_stats_state::IsSet,
-    St::LabeledAccountCount: reporter_stats_state::IsSet,
+    St::LabeledRecordCount: reporter_stats_state::IsSet,
     St::ReportedRecordCount: reporter_stats_state::IsSet,
     St::TakendownAccountCount: reporter_stats_state::IsSet,
-    St::RecordReportCount: reporter_stats_state::IsSet,
-    St::AccountReportCount: reporter_stats_state::IsSet,
     St::TakendownRecordCount: reporter_stats_state::IsSet,
-    St::LabeledRecordCount: reporter_stats_state::IsSet,
     St::ReportedAccountCount: reporter_stats_state::IsSet,
+    St::LabeledAccountCount: reporter_stats_state::IsSet,
+    St::AccountReportCount: reporter_stats_state::IsSet,
+    St::RecordReportCount: reporter_stats_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ReporterStats<S> {
@@ -10295,104 +10295,104 @@ pub mod scheduled_action_view_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Did;
-        type Id;
         type Status;
-        type Action;
         type CreatedBy;
+        type Id;
         type CreatedAt;
+        type Action;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Did = Unset;
-        type Id = Unset;
         type Status = Unset;
-        type Action = Unset;
         type CreatedBy = Unset;
+        type Id = Unset;
         type CreatedAt = Unset;
+        type Action = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
         type Did = Set<members::did>;
-        type Id = St::Id;
         type Status = St::Status;
-        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
+        type Id = St::Id;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `id` field to Set
-    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetId<St> {}
-    impl<St: State> State for SetId<St> {
-        type Did = St::Did;
-        type Id = Set<members::id>;
-        type Status = St::Status;
         type Action = St::Action;
-        type CreatedBy = St::CreatedBy;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `status` field to Set
     pub struct SetStatus<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetStatus<St> {}
     impl<St: State> State for SetStatus<St> {
         type Did = St::Did;
-        type Id = St::Id;
         type Status = Set<members::status>;
-        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `action` field to Set
-    pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAction<St> {}
-    impl<St: State> State for SetAction<St> {
-        type Did = St::Did;
         type Id = St::Id;
-        type Status = St::Status;
-        type Action = Set<members::action>;
-        type CreatedBy = St::CreatedBy;
         type CreatedAt = St::CreatedAt;
+        type Action = St::Action;
     }
     ///State transition - sets the `created_by` field to Set
     pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
     impl<St: State> State for SetCreatedBy<St> {
         type Did = St::Did;
-        type Id = St::Id;
         type Status = St::Status;
-        type Action = St::Action;
         type CreatedBy = Set<members::created_by>;
+        type Id = St::Id;
+        type CreatedAt = St::CreatedAt;
+        type Action = St::Action;
+    }
+    ///State transition - sets the `id` field to Set
+    pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetId<St> {}
+    impl<St: State> State for SetId<St> {
+        type Did = St::Did;
+        type Status = St::Status;
+        type CreatedBy = St::CreatedBy;
+        type Id = Set<members::id>;
         type CreatedAt = St::CreatedAt;
+        type Action = St::Action;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Did = St::Did;
-        type Id = St::Id;
         type Status = St::Status;
-        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
+        type Id = St::Id;
         type CreatedAt = Set<members::created_at>;
+        type Action = St::Action;
+    }
+    ///State transition - sets the `action` field to Set
+    pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAction<St> {}
+    impl<St: State> State for SetAction<St> {
+        type Did = St::Did;
+        type Status = St::Status;
+        type CreatedBy = St::CreatedBy;
+        type Id = St::Id;
+        type CreatedAt = St::CreatedAt;
+        type Action = Set<members::action>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `id` field
-        pub struct id(());
         ///Marker type for the `status` field
         pub struct status(());
-        ///Marker type for the `action` field
-        pub struct action(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
+        ///Marker type for the `id` field
+        pub struct id(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `action` field
+        pub struct action(());
     }
 }
 
@@ -10718,11 +10718,11 @@ impl<S: BosStr, St> ScheduledActionViewBuilder<S, St>
 where
     St: scheduled_action_view_state::State,
     St::Did: scheduled_action_view_state::IsSet,
-    St::Id: scheduled_action_view_state::IsSet,
     St::Status: scheduled_action_view_state::IsSet,
-    St::Action: scheduled_action_view_state::IsSet,
     St::CreatedBy: scheduled_action_view_state::IsSet,
+    St::Id: scheduled_action_view_state::IsSet,
     St::CreatedAt: scheduled_action_view_state::IsSet,
+    St::Action: scheduled_action_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ScheduledActionView<S> {
@@ -10781,85 +10781,85 @@ pub mod subject_status_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type ReviewState;
-        type Subject;
         type Id;
-        type CreatedAt;
         type UpdatedAt;
+        type ReviewState;
+        type CreatedAt;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type ReviewState = Unset;
-        type Subject = Unset;
         type Id = Unset;
-        type CreatedAt = Unset;
         type UpdatedAt = Unset;
-    }
-    ///State transition - sets the `review_state` field to Set
-    pub struct SetReviewState<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReviewState<St> {}
-    impl<St: State> State for SetReviewState<St> {
-        type ReviewState = Set<members::review_state>;
-        type Subject = St::Subject;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type ReviewState = St::ReviewState;
-        type Subject = Set<members::subject>;
-        type Id = St::Id;
-        type CreatedAt = St::CreatedAt;
-        type UpdatedAt = St::UpdatedAt;
+        type ReviewState = Unset;
+        type CreatedAt = Unset;
+        type Subject = Unset;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
+        type Id = Set<members::id>;
+        type UpdatedAt = St::UpdatedAt;
         type ReviewState = St::ReviewState;
+        type CreatedAt = St::CreatedAt;
         type Subject = St::Subject;
-        type Id = Set<members::id>;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type Id = St::Id;
+        type UpdatedAt = Set<members::updated_at>;
+        type ReviewState = St::ReviewState;
         type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `review_state` field to Set
+    pub struct SetReviewState<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReviewState<St> {}
+    impl<St: State> State for SetReviewState<St> {
+        type Id = St::Id;
         type UpdatedAt = St::UpdatedAt;
+        type ReviewState = Set<members::review_state>;
+        type CreatedAt = St::CreatedAt;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type ReviewState = St::ReviewState;
-        type Subject = St::Subject;
         type Id = St::Id;
-        type CreatedAt = Set<members::created_at>;
         type UpdatedAt = St::UpdatedAt;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
         type ReviewState = St::ReviewState;
+        type CreatedAt = Set<members::created_at>;
         type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
         type Id = St::Id;
+        type UpdatedAt = St::UpdatedAt;
+        type ReviewState = St::ReviewState;
         type CreatedAt = St::CreatedAt;
-        type UpdatedAt = Set<members::updated_at>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `review_state` field
-        pub struct review_state(());
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `id` field
         pub struct id(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
+        ///Marker type for the `review_state` field
+        pub struct review_state(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -11331,11 +11331,11 @@ where
 impl<S: BosStr, St> SubjectStatusViewBuilder<S, St>
 where
     St: subject_status_view_state::State,
-    St::ReviewState: subject_status_view_state::IsSet,
-    St::Subject: subject_status_view_state::IsSet,
     St::Id: subject_status_view_state::IsSet,
-    St::CreatedAt: subject_status_view_state::IsSet,
     St::UpdatedAt: subject_status_view_state::IsSet,
+    St::ReviewState: subject_status_view_state::IsSet,
+    St::CreatedAt: subject_status_view_state::IsSet,
+    St::Subject: subject_status_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubjectStatusView<S> {
@@ -11414,37 +11414,37 @@ pub mod subject_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type Subject;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type Subject = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type Subject = St::Subject;
+        type Type = Unset;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Type = St::Type;
         type Subject = Set<members::subject>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Subject = St::Subject;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `subject` field
         pub struct subject(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -11588,8 +11588,8 @@ where
 impl<S: BosStr, St> SubjectViewBuilder<S, St>
 where
     St: subject_view_state::State,
-    St::Type: subject_view_state::IsSet,
     St::Subject: subject_view_state::IsSet,
+    St::Type: subject_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SubjectView<S> {
@@ -11630,51 +11630,51 @@ pub mod video_details_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Length;
         type Width;
         type Height;
-        type Length;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Length = Unset;
         type Width = Unset;
         type Height = Unset;
-        type Length = Unset;
+    }
+    ///State transition - sets the `length` field to Set
+    pub struct SetLength<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetLength<St> {}
+    impl<St: State> State for SetLength<St> {
+        type Length = Set<members::length>;
+        type Width = St::Width;
+        type Height = St::Height;
     }
     ///State transition - sets the `width` field to Set
     pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWidth<St> {}
     impl<St: State> State for SetWidth<St> {
+        type Length = St::Length;
         type Width = Set<members::width>;
         type Height = St::Height;
-        type Length = St::Length;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
-        type Height = Set<members::height>;
         type Length = St::Length;
-    }
-    ///State transition - sets the `length` field to Set
-    pub struct SetLength<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetLength<St> {}
-    impl<St: State> State for SetLength<St> {
         type Width = St::Width;
-        type Height = St::Height;
-        type Length = Set<members::length>;
+        type Height = Set<members::height>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `length` field
+        pub struct length(());
         ///Marker type for the `width` field
         pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
-        ///Marker type for the `length` field
-        pub struct length(());
     }
 }
 
@@ -11763,9 +11763,9 @@ where
 impl<S: BosStr, St> VideoDetailsBuilder<S, St>
 where
     St: video_details_state::State,
+    St::Length: video_details_state::IsSet,
     St::Width: video_details_state::IsSet,
     St::Height: video_details_state::IsSet,
-    St::Length: video_details_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> VideoDetails<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs b/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs
index cec98bfb..abd9d931 100644
--- a/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs
+++ b/crates/jacquard-api/src/tools_ozone/moderation/cancel_scheduled_actions.rs
@@ -417,37 +417,37 @@ pub mod failed_cancellation_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Did;
         type Error;
+        type Did;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Did = Unset;
         type Error = Unset;
-    }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
-        type Did = Set<members::did>;
-        type Error = St::Error;
+        type Did = Unset;
     }
     ///State transition - sets the `error` field to Set
     pub struct SetError<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetError<St> {}
     impl<St: State> State for SetError<St> {
-        type Did = St::Did;
         type Error = Set<members::error>;
+        type Did = St::Did;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Error = St::Error;
+        type Did = Set<members::did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `did` field
-        pub struct did(());
         ///Marker type for the `error` field
         pub struct error(());
+        ///Marker type for the `did` field
+        pub struct did(());
     }
 }
 
@@ -530,8 +530,8 @@ impl<S: BosStr, St: failed_cancellation_state::State> FailedCancellationBuilder<
 impl<S: BosStr, St> FailedCancellationBuilder<S, St>
 where
     St: failed_cancellation_state::State,
-    St::Did: failed_cancellation_state::IsSet,
     St::Error: failed_cancellation_state::IsSet,
+    St::Did: failed_cancellation_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FailedCancellation<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs b/crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs
index eaebc36d..d00e8344 100644
--- a/crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs
+++ b/crates/jacquard-api/src/tools_ozone/moderation/emit_event.rs
@@ -231,51 +231,51 @@ pub mod emit_event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedBy;
         type Event;
         type Subject;
-        type CreatedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedBy = Unset;
         type Event = Unset;
         type Subject = Unset;
-        type CreatedBy = Unset;
+    }
+    ///State transition - sets the `created_by` field to Set
+    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
+    impl<St: State> State for SetCreatedBy<St> {
+        type CreatedBy = Set<members::created_by>;
+        type Event = St::Event;
+        type Subject = St::Subject;
     }
     ///State transition - sets the `event` field to Set
     pub struct SetEvent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEvent<St> {}
     impl<St: State> State for SetEvent<St> {
+        type CreatedBy = St::CreatedBy;
         type Event = Set<members::event>;
         type Subject = St::Subject;
-        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Event = St::Event;
-        type Subject = Set<members::subject>;
         type CreatedBy = St::CreatedBy;
-    }
-    ///State transition - sets the `created_by` field to Set
-    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
-    impl<St: State> State for SetCreatedBy<St> {
         type Event = St::Event;
-        type Subject = St::Subject;
-        type CreatedBy = Set<members::created_by>;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_by` field
+        pub struct created_by(());
         ///Marker type for the `event` field
         pub struct event(());
         ///Marker type for the `subject` field
         pub struct subject(());
-        ///Marker type for the `created_by` field
-        pub struct created_by(());
     }
 }
 
@@ -410,9 +410,9 @@ impl<S: BosStr, St: emit_event_state::State> EmitEventBuilder<S, St> {
 impl<S: BosStr, St> EmitEventBuilder<S, St>
 where
     St: emit_event_state::State,
+    St::CreatedBy: emit_event_state::IsSet,
     St::Event: emit_event_state::IsSet,
     St::Subject: emit_event_state::IsSet,
-    St::CreatedBy: emit_event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> EmitEvent<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs b/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs
index f35c872d..68b0260a 100644
--- a/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs
+++ b/crates/jacquard-api/src/tools_ozone/moderation/get_account_timeline.rs
@@ -905,49 +905,49 @@ pub mod timeline_item_summary_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type EventSubjectType;
         type EventType;
+        type EventSubjectType;
         type Count;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type EventSubjectType = Unset;
         type EventType = Unset;
+        type EventSubjectType = Unset;
         type Count = Unset;
     }
-    ///State transition - sets the `event_subject_type` field to Set
-    pub struct SetEventSubjectType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEventSubjectType<St> {}
-    impl<St: State> State for SetEventSubjectType<St> {
-        type EventSubjectType = Set<members::event_subject_type>;
-        type EventType = St::EventType;
-        type Count = St::Count;
-    }
     ///State transition - sets the `event_type` field to Set
     pub struct SetEventType<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetEventType<St> {}
     impl<St: State> State for SetEventType<St> {
-        type EventSubjectType = St::EventSubjectType;
         type EventType = Set<members::event_type>;
+        type EventSubjectType = St::EventSubjectType;
+        type Count = St::Count;
+    }
+    ///State transition - sets the `event_subject_type` field to Set
+    pub struct SetEventSubjectType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEventSubjectType<St> {}
+    impl<St: State> State for SetEventSubjectType<St> {
+        type EventType = St::EventType;
+        type EventSubjectType = Set<members::event_subject_type>;
         type Count = St::Count;
     }
     ///State transition - sets the `count` field to Set
     pub struct SetCount<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCount<St> {}
     impl<St: State> State for SetCount<St> {
-        type EventSubjectType = St::EventSubjectType;
         type EventType = St::EventType;
+        type EventSubjectType = St::EventSubjectType;
         type Count = Set<members::count>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `event_subject_type` field
-        pub struct event_subject_type(());
         ///Marker type for the `event_type` field
         pub struct event_type(());
+        ///Marker type for the `event_subject_type` field
+        pub struct event_subject_type(());
         ///Marker type for the `count` field
         pub struct count(());
     }
@@ -1048,8 +1048,8 @@ where
 impl<S: BosStr, St> TimelineItemSummaryBuilder<S, St>
 where
     St: timeline_item_summary_state::State,
-    St::EventSubjectType: timeline_item_summary_state::IsSet,
     St::EventType: timeline_item_summary_state::IsSet,
+    St::EventSubjectType: timeline_item_summary_state::IsSet,
     St::Count: timeline_item_summary_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs b/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs
index f7173896..40c55fb6 100644
--- a/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs
+++ b/crates/jacquard-api/src/tools_ozone/moderation/schedule_action.rs
@@ -235,37 +235,37 @@ pub mod failed_scheduling_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subject;
         type Error;
+        type Subject;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subject = Unset;
         type Error = Unset;
-    }
-    ///State transition - sets the `subject` field to Set
-    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubject<St> {}
-    impl<St: State> State for SetSubject<St> {
-        type Subject = Set<members::subject>;
-        type Error = St::Error;
+        type Subject = Unset;
     }
     ///State transition - sets the `error` field to Set
     pub struct SetError<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetError<St> {}
     impl<St: State> State for SetError<St> {
-        type Subject = St::Subject;
         type Error = Set<members::error>;
+        type Subject = St::Subject;
+    }
+    ///State transition - sets the `subject` field to Set
+    pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubject<St> {}
+    impl<St: State> State for SetSubject<St> {
+        type Error = St::Error;
+        type Subject = Set<members::subject>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subject` field
-        pub struct subject(());
         ///Marker type for the `error` field
         pub struct error(());
+        ///Marker type for the `subject` field
+        pub struct subject(());
     }
 }
 
@@ -348,8 +348,8 @@ where
 impl<S: BosStr, St> FailedSchedulingBuilder<S, St>
 where
     St: failed_scheduling_state::State,
-    St::Subject: failed_scheduling_state::IsSet,
     St::Error: failed_scheduling_state::IsSet,
+    St::Subject: failed_scheduling_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> FailedScheduling<S> {
@@ -686,67 +686,67 @@ pub mod schedule_action_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Subjects;
         type Action;
-        type CreatedBy;
+        type Subjects;
         type Scheduling;
+        type CreatedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Subjects = Unset;
         type Action = Unset;
-        type CreatedBy = Unset;
+        type Subjects = Unset;
         type Scheduling = Unset;
-    }
-    ///State transition - sets the `subjects` field to Set
-    pub struct SetSubjects<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSubjects<St> {}
-    impl<St: State> State for SetSubjects<St> {
-        type Subjects = Set<members::subjects>;
-        type Action = St::Action;
-        type CreatedBy = St::CreatedBy;
-        type Scheduling = St::Scheduling;
+        type CreatedBy = Unset;
     }
     ///State transition - sets the `action` field to Set
     pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAction<St> {}
     impl<St: State> State for SetAction<St> {
-        type Subjects = St::Subjects;
         type Action = Set<members::action>;
-        type CreatedBy = St::CreatedBy;
+        type Subjects = St::Subjects;
         type Scheduling = St::Scheduling;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `created_by` field to Set
-    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
-    impl<St: State> State for SetCreatedBy<St> {
-        type Subjects = St::Subjects;
+    ///State transition - sets the `subjects` field to Set
+    pub struct SetSubjects<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSubjects<St> {}
+    impl<St: State> State for SetSubjects<St> {
         type Action = St::Action;
-        type CreatedBy = Set<members::created_by>;
+        type Subjects = Set<members::subjects>;
         type Scheduling = St::Scheduling;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `scheduling` field to Set
     pub struct SetScheduling<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScheduling<St> {}
     impl<St: State> State for SetScheduling<St> {
-        type Subjects = St::Subjects;
         type Action = St::Action;
-        type CreatedBy = St::CreatedBy;
+        type Subjects = St::Subjects;
         type Scheduling = Set<members::scheduling>;
+        type CreatedBy = St::CreatedBy;
+    }
+    ///State transition - sets the `created_by` field to Set
+    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
+    impl<St: State> State for SetCreatedBy<St> {
+        type Action = St::Action;
+        type Subjects = St::Subjects;
+        type Scheduling = St::Scheduling;
+        type CreatedBy = Set<members::created_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `subjects` field
-        pub struct subjects(());
         ///Marker type for the `action` field
         pub struct action(());
-        ///Marker type for the `created_by` field
-        pub struct created_by(());
+        ///Marker type for the `subjects` field
+        pub struct subjects(());
         ///Marker type for the `scheduling` field
         pub struct scheduling(());
+        ///Marker type for the `created_by` field
+        pub struct created_by(());
     }
 }
 
@@ -873,10 +873,10 @@ where
 impl<S: BosStr, St> ScheduleActionBuilder<S, St>
 where
     St: schedule_action_state::State,
-    St::Subjects: schedule_action_state::IsSet,
     St::Action: schedule_action_state::IsSet,
-    St::CreatedBy: schedule_action_state::IsSet,
+    St::Subjects: schedule_action_state::IsSet,
     St::Scheduling: schedule_action_state::IsSet,
+    St::CreatedBy: schedule_action_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ScheduleAction<S> {
@@ -915,37 +915,37 @@ pub mod scheduled_action_results_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Succeeded;
         type Failed;
+        type Succeeded;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Succeeded = Unset;
         type Failed = Unset;
-    }
-    ///State transition - sets the `succeeded` field to Set
-    pub struct SetSucceeded<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSucceeded<St> {}
-    impl<St: State> State for SetSucceeded<St> {
-        type Succeeded = Set<members::succeeded>;
-        type Failed = St::Failed;
+        type Succeeded = Unset;
     }
     ///State transition - sets the `failed` field to Set
     pub struct SetFailed<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetFailed<St> {}
     impl<St: State> State for SetFailed<St> {
-        type Succeeded = St::Succeeded;
         type Failed = Set<members::failed>;
+        type Succeeded = St::Succeeded;
+    }
+    ///State transition - sets the `succeeded` field to Set
+    pub struct SetSucceeded<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSucceeded<St> {}
+    impl<St: State> State for SetSucceeded<St> {
+        type Failed = St::Failed;
+        type Succeeded = Set<members::succeeded>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `succeeded` field
-        pub struct succeeded(());
         ///Marker type for the `failed` field
         pub struct failed(());
+        ///Marker type for the `succeeded` field
+        pub struct succeeded(());
     }
 }
 
@@ -1027,8 +1027,8 @@ where
 impl<S: BosStr, St> ScheduledActionResultsBuilder<S, St>
 where
     St: scheduled_action_results_state::State,
-    St::Succeeded: scheduled_action_results_state::IsSet,
     St::Failed: scheduled_action_results_state::IsSet,
+    St::Succeeded: scheduled_action_results_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> ScheduledActionResults<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/safelink.rs b/crates/jacquard-api/src/tools_ozone/safelink.rs
index 9f2a8b26..7df740b6 100644
--- a/crates/jacquard-api/src/tools_ozone/safelink.rs
+++ b/crates/jacquard-api/src/tools_ozone/safelink.rs
@@ -422,151 +422,151 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Pattern;
         type Reason;
-        type EventType;
-        type CreatedAt;
+        type Url;
         type Action;
+        type CreatedAt;
+        type EventType;
         type CreatedBy;
-        type Url;
         type Id;
+        type Pattern;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Pattern = Unset;
         type Reason = Unset;
-        type EventType = Unset;
-        type CreatedAt = Unset;
+        type Url = Unset;
         type Action = Unset;
+        type CreatedAt = Unset;
+        type EventType = Unset;
         type CreatedBy = Unset;
-        type Url = Unset;
         type Id = Unset;
-    }
-    ///State transition - sets the `pattern` field to Set
-    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPattern<St> {}
-    impl<St: State> State for SetPattern<St> {
-        type Pattern = Set<members::pattern>;
-        type Reason = St::Reason;
-        type EventType = St::EventType;
-        type CreatedAt = St::CreatedAt;
-        type Action = St::Action;
-        type CreatedBy = St::CreatedBy;
-        type Url = St::Url;
-        type Id = St::Id;
+        type Pattern = Unset;
     }
     ///State transition - sets the `reason` field to Set
     pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReason<St> {}
     impl<St: State> State for SetReason<St> {
-        type Pattern = St::Pattern;
         type Reason = Set<members::reason>;
-        type EventType = St::EventType;
-        type CreatedAt = St::CreatedAt;
+        type Url = St::Url;
         type Action = St::Action;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
         type CreatedBy = St::CreatedBy;
-        type Url = St::Url;
         type Id = St::Id;
-    }
-    ///State transition - sets the `event_type` field to Set
-    pub struct SetEventType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetEventType<St> {}
-    impl<St: State> State for SetEventType<St> {
         type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
         type Reason = St::Reason;
-        type EventType = Set<members::event_type>;
-        type CreatedAt = St::CreatedAt;
+        type Url = Set<members::url>;
         type Action = St::Action;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
         type CreatedBy = St::CreatedBy;
+        type Id = St::Id;
+        type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `action` field to Set
+    pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAction<St> {}
+    impl<St: State> State for SetAction<St> {
+        type Reason = St::Reason;
         type Url = St::Url;
+        type Action = Set<members::action>;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
+        type CreatedBy = St::CreatedBy;
         type Id = St::Id;
+        type Pattern = St::Pattern;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Pattern = St::Pattern;
         type Reason = St::Reason;
-        type EventType = St::EventType;
-        type CreatedAt = Set<members::created_at>;
+        type Url = St::Url;
         type Action = St::Action;
+        type CreatedAt = Set<members::created_at>;
+        type EventType = St::EventType;
         type CreatedBy = St::CreatedBy;
-        type Url = St::Url;
         type Id = St::Id;
-    }
-    ///State transition - sets the `action` field to Set
-    pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAction<St> {}
-    impl<St: State> State for SetAction<St> {
         type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `event_type` field to Set
+    pub struct SetEventType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetEventType<St> {}
+    impl<St: State> State for SetEventType<St> {
         type Reason = St::Reason;
-        type EventType = St::EventType;
+        type Url = St::Url;
+        type Action = St::Action;
         type CreatedAt = St::CreatedAt;
-        type Action = Set<members::action>;
+        type EventType = Set<members::event_type>;
         type CreatedBy = St::CreatedBy;
-        type Url = St::Url;
         type Id = St::Id;
+        type Pattern = St::Pattern;
     }
     ///State transition - sets the `created_by` field to Set
     pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
     impl<St: State> State for SetCreatedBy<St> {
-        type Pattern = St::Pattern;
         type Reason = St::Reason;
-        type EventType = St::EventType;
-        type CreatedAt = St::CreatedAt;
+        type Url = St::Url;
         type Action = St::Action;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
         type CreatedBy = Set<members::created_by>;
-        type Url = St::Url;
         type Id = St::Id;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
         type Pattern = St::Pattern;
-        type Reason = St::Reason;
-        type EventType = St::EventType;
-        type CreatedAt = St::CreatedAt;
-        type Action = St::Action;
-        type CreatedBy = St::CreatedBy;
-        type Url = Set<members::url>;
-        type Id = St::Id;
     }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Pattern = St::Pattern;
         type Reason = St::Reason;
-        type EventType = St::EventType;
-        type CreatedAt = St::CreatedAt;
+        type Url = St::Url;
         type Action = St::Action;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
         type CreatedBy = St::CreatedBy;
-        type Url = St::Url;
         type Id = Set<members::id>;
+        type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `pattern` field to Set
+    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPattern<St> {}
+    impl<St: State> State for SetPattern<St> {
+        type Reason = St::Reason;
+        type Url = St::Url;
+        type Action = St::Action;
+        type CreatedAt = St::CreatedAt;
+        type EventType = St::EventType;
+        type CreatedBy = St::CreatedBy;
+        type Id = St::Id;
+        type Pattern = Set<members::pattern>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `pattern` field
-        pub struct pattern(());
         ///Marker type for the `reason` field
         pub struct reason(());
-        ///Marker type for the `event_type` field
-        pub struct event_type(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `url` field
+        pub struct url(());
         ///Marker type for the `action` field
         pub struct action(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `event_type` field
+        pub struct event_type(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `id` field
         pub struct id(());
+        ///Marker type for the `pattern` field
+        pub struct pattern(());
     }
 }
 
@@ -773,14 +773,14 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::Pattern: event_state::IsSet,
     St::Reason: event_state::IsSet,
-    St::EventType: event_state::IsSet,
-    St::CreatedAt: event_state::IsSet,
+    St::Url: event_state::IsSet,
     St::Action: event_state::IsSet,
+    St::CreatedAt: event_state::IsSet,
+    St::EventType: event_state::IsSet,
     St::CreatedBy: event_state::IsSet,
-    St::Url: event_state::IsSet,
     St::Id: event_state::IsSet,
+    St::Pattern: event_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Event<S> {
@@ -1042,127 +1042,127 @@ pub mod url_rule_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Pattern;
-        type Action;
         type UpdatedAt;
-        type Url;
+        type Reason;
+        type Action;
         type CreatedBy;
         type CreatedAt;
-        type Reason;
+        type Pattern;
+        type Url;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Pattern = Unset;
-        type Action = Unset;
         type UpdatedAt = Unset;
-        type Url = Unset;
+        type Reason = Unset;
+        type Action = Unset;
         type CreatedBy = Unset;
         type CreatedAt = Unset;
-        type Reason = Unset;
+        type Pattern = Unset;
+        type Url = Unset;
     }
-    ///State transition - sets the `pattern` field to Set
-    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPattern<St> {}
-    impl<St: State> State for SetPattern<St> {
-        type Pattern = Set<members::pattern>;
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
+        type UpdatedAt = Set<members::updated_at>;
+        type Reason = St::Reason;
         type Action = St::Action;
-        type UpdatedAt = St::UpdatedAt;
+        type CreatedBy = St::CreatedBy;
+        type CreatedAt = St::CreatedAt;
+        type Pattern = St::Pattern;
         type Url = St::Url;
+    }
+    ///State transition - sets the `reason` field to Set
+    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReason<St> {}
+    impl<St: State> State for SetReason<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type Reason = Set<members::reason>;
+        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
         type CreatedAt = St::CreatedAt;
-        type Reason = St::Reason;
+        type Pattern = St::Pattern;
+        type Url = St::Url;
     }
     ///State transition - sets the `action` field to Set
     pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAction<St> {}
     impl<St: State> State for SetAction<St> {
-        type Pattern = St::Pattern;
-        type Action = Set<members::action>;
         type UpdatedAt = St::UpdatedAt;
-        type Url = St::Url;
-        type CreatedBy = St::CreatedBy;
-        type CreatedAt = St::CreatedAt;
         type Reason = St::Reason;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type Pattern = St::Pattern;
-        type Action = St::Action;
-        type UpdatedAt = Set<members::updated_at>;
-        type Url = St::Url;
+        type Action = Set<members::action>;
         type CreatedBy = St::CreatedBy;
         type CreatedAt = St::CreatedAt;
-        type Reason = St::Reason;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
         type Pattern = St::Pattern;
-        type Action = St::Action;
-        type UpdatedAt = St::UpdatedAt;
-        type Url = Set<members::url>;
-        type CreatedBy = St::CreatedBy;
-        type CreatedAt = St::CreatedAt;
-        type Reason = St::Reason;
+        type Url = St::Url;
     }
     ///State transition - sets the `created_by` field to Set
     pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
     impl<St: State> State for SetCreatedBy<St> {
-        type Pattern = St::Pattern;
-        type Action = St::Action;
         type UpdatedAt = St::UpdatedAt;
-        type Url = St::Url;
+        type Reason = St::Reason;
+        type Action = St::Action;
         type CreatedBy = Set<members::created_by>;
         type CreatedAt = St::CreatedAt;
-        type Reason = St::Reason;
+        type Pattern = St::Pattern;
+        type Url = St::Url;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Pattern = St::Pattern;
-        type Action = St::Action;
         type UpdatedAt = St::UpdatedAt;
-        type Url = St::Url;
+        type Reason = St::Reason;
+        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
         type CreatedAt = Set<members::created_at>;
-        type Reason = St::Reason;
-    }
-    ///State transition - sets the `reason` field to Set
-    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReason<St> {}
-    impl<St: State> State for SetReason<St> {
         type Pattern = St::Pattern;
-        type Action = St::Action;
+        type Url = St::Url;
+    }
+    ///State transition - sets the `pattern` field to Set
+    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPattern<St> {}
+    impl<St: State> State for SetPattern<St> {
         type UpdatedAt = St::UpdatedAt;
+        type Reason = St::Reason;
+        type Action = St::Action;
+        type CreatedBy = St::CreatedBy;
+        type CreatedAt = St::CreatedAt;
+        type Pattern = Set<members::pattern>;
         type Url = St::Url;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
+        type UpdatedAt = St::UpdatedAt;
+        type Reason = St::Reason;
+        type Action = St::Action;
         type CreatedBy = St::CreatedBy;
         type CreatedAt = St::CreatedAt;
-        type Reason = Set<members::reason>;
+        type Pattern = St::Pattern;
+        type Url = Set<members::url>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `pattern` field
-        pub struct pattern(());
-        ///Marker type for the `action` field
-        pub struct action(());
         ///Marker type for the `updated_at` field
         pub struct updated_at(());
-        ///Marker type for the `url` field
-        pub struct url(());
+        ///Marker type for the `reason` field
+        pub struct reason(());
+        ///Marker type for the `action` field
+        pub struct action(());
         ///Marker type for the `created_by` field
         pub struct created_by(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `reason` field
-        pub struct reason(());
+        ///Marker type for the `pattern` field
+        pub struct pattern(());
+        ///Marker type for the `url` field
+        pub struct url(());
     }
 }
 
@@ -1349,13 +1349,13 @@ where
 impl<S: BosStr, St> UrlRuleBuilder<S, St>
 where
     St: url_rule_state::State,
-    St::Pattern: url_rule_state::IsSet,
-    St::Action: url_rule_state::IsSet,
     St::UpdatedAt: url_rule_state::IsSet,
-    St::Url: url_rule_state::IsSet,
+    St::Reason: url_rule_state::IsSet,
+    St::Action: url_rule_state::IsSet,
     St::CreatedBy: url_rule_state::IsSet,
     St::CreatedAt: url_rule_state::IsSet,
-    St::Reason: url_rule_state::IsSet,
+    St::Pattern: url_rule_state::IsSet,
+    St::Url: url_rule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UrlRule<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs b/crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs
index 66f135ee..16d2cfd5 100644
--- a/crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs
+++ b/crates/jacquard-api/src/tools_ozone/safelink/add_rule.rs
@@ -141,66 +141,66 @@ pub mod add_rule_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Action;
-        type Pattern;
-        type Url;
         type Reason;
+        type Url;
+        type Pattern;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Action = Unset;
-        type Pattern = Unset;
-        type Url = Unset;
         type Reason = Unset;
+        type Url = Unset;
+        type Pattern = Unset;
     }
     ///State transition - sets the `action` field to Set
     pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAction<St> {}
     impl<St: State> State for SetAction<St> {
         type Action = Set<members::action>;
-        type Pattern = St::Pattern;
-        type Url = St::Url;
         type Reason = St::Reason;
+        type Url = St::Url;
+        type Pattern = St::Pattern;
     }
-    ///State transition - sets the `pattern` field to Set
-    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPattern<St> {}
-    impl<St: State> State for SetPattern<St> {
+    ///State transition - sets the `reason` field to Set
+    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetReason<St> {}
+    impl<St: State> State for SetReason<St> {
         type Action = St::Action;
-        type Pattern = Set<members::pattern>;
+        type Reason = Set<members::reason>;
         type Url = St::Url;
-        type Reason = St::Reason;
+        type Pattern = St::Pattern;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
         type Action = St::Action;
-        type Pattern = St::Pattern;
-        type Url = Set<members::url>;
         type Reason = St::Reason;
+        type Url = Set<members::url>;
+        type Pattern = St::Pattern;
     }
-    ///State transition - sets the `reason` field to Set
-    pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetReason<St> {}
-    impl<St: State> State for SetReason<St> {
+    ///State transition - sets the `pattern` field to Set
+    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPattern<St> {}
+    impl<St: State> State for SetPattern<St> {
         type Action = St::Action;
-        type Pattern = St::Pattern;
+        type Reason = St::Reason;
         type Url = St::Url;
-        type Reason = Set<members::reason>;
+        type Pattern = Set<members::pattern>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `action` field
         pub struct action(());
-        ///Marker type for the `pattern` field
-        pub struct pattern(());
-        ///Marker type for the `url` field
-        pub struct url(());
         ///Marker type for the `reason` field
         pub struct reason(());
+        ///Marker type for the `url` field
+        pub struct url(());
+        ///Marker type for the `pattern` field
+        pub struct pattern(());
     }
 }
 
@@ -342,9 +342,9 @@ impl<S: BosStr, St> AddRuleBuilder<S, St>
 where
     St: add_rule_state::State,
     St::Action: add_rule_state::IsSet,
-    St::Pattern: add_rule_state::IsSet,
-    St::Url: add_rule_state::IsSet,
     St::Reason: add_rule_state::IsSet,
+    St::Url: add_rule_state::IsSet,
+    St::Pattern: add_rule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AddRule<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs b/crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs
index 9635f79b..2624cad8 100644
--- a/crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs
+++ b/crates/jacquard-api/src/tools_ozone/safelink/remove_rule.rs
@@ -126,37 +126,37 @@ pub mod remove_rule_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Pattern;
         type Url;
+        type Pattern;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Pattern = Unset;
         type Url = Unset;
-    }
-    ///State transition - sets the `pattern` field to Set
-    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPattern<St> {}
-    impl<St: State> State for SetPattern<St> {
-        type Pattern = Set<members::pattern>;
-        type Url = St::Url;
+        type Pattern = Unset;
     }
     ///State transition - sets the `url` field to Set
     pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUrl<St> {}
     impl<St: State> State for SetUrl<St> {
-        type Pattern = St::Pattern;
         type Url = Set<members::url>;
+        type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `pattern` field to Set
+    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPattern<St> {}
+    impl<St: State> State for SetPattern<St> {
+        type Url = St::Url;
+        type Pattern = Set<members::pattern>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `pattern` field
-        pub struct pattern(());
         ///Marker type for the `url` field
         pub struct url(());
+        ///Marker type for the `pattern` field
+        pub struct pattern(());
     }
 }
 
@@ -252,8 +252,8 @@ where
 impl<S: BosStr, St> RemoveRuleBuilder<S, St>
 where
     St: remove_rule_state::State,
-    St::Pattern: remove_rule_state::IsSet,
     St::Url: remove_rule_state::IsSet,
+    St::Pattern: remove_rule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RemoveRule<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs b/crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs
index 35773be2..3aca925c 100644
--- a/crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs
+++ b/crates/jacquard-api/src/tools_ozone/safelink/update_rule.rs
@@ -130,67 +130,67 @@ pub mod update_rule_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Url;
-        type Pattern;
         type Reason;
         type Action;
+        type Url;
+        type Pattern;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Url = Unset;
-        type Pattern = Unset;
         type Reason = Unset;
         type Action = Unset;
-    }
-    ///State transition - sets the `url` field to Set
-    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUrl<St> {}
-    impl<St: State> State for SetUrl<St> {
-        type Url = Set<members::url>;
-        type Pattern = St::Pattern;
-        type Reason = St::Reason;
-        type Action = St::Action;
-    }
-    ///State transition - sets the `pattern` field to Set
-    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPattern<St> {}
-    impl<St: State> State for SetPattern<St> {
-        type Url = St::Url;
-        type Pattern = Set<members::pattern>;
-        type Reason = St::Reason;
-        type Action = St::Action;
+        type Url = Unset;
+        type Pattern = Unset;
     }
     ///State transition - sets the `reason` field to Set
     pub struct SetReason<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetReason<St> {}
     impl<St: State> State for SetReason<St> {
-        type Url = St::Url;
-        type Pattern = St::Pattern;
         type Reason = Set<members::reason>;
         type Action = St::Action;
+        type Url = St::Url;
+        type Pattern = St::Pattern;
     }
     ///State transition - sets the `action` field to Set
     pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAction<St> {}
     impl<St: State> State for SetAction<St> {
+        type Reason = St::Reason;
+        type Action = Set<members::action>;
         type Url = St::Url;
         type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `url` field to Set
+    pub struct SetUrl<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUrl<St> {}
+    impl<St: State> State for SetUrl<St> {
         type Reason = St::Reason;
-        type Action = Set<members::action>;
+        type Action = St::Action;
+        type Url = Set<members::url>;
+        type Pattern = St::Pattern;
+    }
+    ///State transition - sets the `pattern` field to Set
+    pub struct SetPattern<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPattern<St> {}
+    impl<St: State> State for SetPattern<St> {
+        type Reason = St::Reason;
+        type Action = St::Action;
+        type Url = St::Url;
+        type Pattern = Set<members::pattern>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `url` field
-        pub struct url(());
-        ///Marker type for the `pattern` field
-        pub struct pattern(());
         ///Marker type for the `reason` field
         pub struct reason(());
         ///Marker type for the `action` field
         pub struct action(());
+        ///Marker type for the `url` field
+        pub struct url(());
+        ///Marker type for the `pattern` field
+        pub struct pattern(());
     }
 }
 
@@ -331,10 +331,10 @@ where
 impl<S: BosStr, St> UpdateRuleBuilder<S, St>
 where
     St: update_rule_state::State,
-    St::Url: update_rule_state::IsSet,
-    St::Pattern: update_rule_state::IsSet,
     St::Reason: update_rule_state::IsSet,
     St::Action: update_rule_state::IsSet,
+    St::Url: update_rule_state::IsSet,
+    St::Pattern: update_rule_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpdateRule<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/set.rs b/crates/jacquard-api/src/tools_ozone/set.rs
index f7078748..02927b8a 100644
--- a/crates/jacquard-api/src/tools_ozone/set.rs
+++ b/crates/jacquard-api/src/tools_ozone/set.rs
@@ -283,67 +283,67 @@ pub mod set_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type UpdatedAt;
         type CreatedAt;
-        type Name;
         type SetSize;
+        type UpdatedAt;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type UpdatedAt = Unset;
         type CreatedAt = Unset;
-        type Name = Unset;
         type SetSize = Unset;
-    }
-    ///State transition - sets the `updated_at` field to Set
-    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
-    impl<St: State> State for SetUpdatedAt<St> {
-        type UpdatedAt = Set<members::updated_at>;
-        type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
-        type SetSize = St::SetSize;
+        type UpdatedAt = Unset;
+        type Name = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type UpdatedAt = St::UpdatedAt;
         type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
         type SetSize = St::SetSize;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
         type UpdatedAt = St::UpdatedAt;
-        type CreatedAt = St::CreatedAt;
-        type Name = Set<members::name>;
-        type SetSize = St::SetSize;
+        type Name = St::Name;
     }
     ///State transition - sets the `set_size` field to Set
     pub struct SetSetSize<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSetSize<St> {}
     impl<St: State> State for SetSetSize<St> {
+        type CreatedAt = St::CreatedAt;
+        type SetSize = Set<members::set_size>;
         type UpdatedAt = St::UpdatedAt;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `updated_at` field to Set
+    pub struct SetUpdatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUpdatedAt<St> {}
+    impl<St: State> State for SetUpdatedAt<St> {
         type CreatedAt = St::CreatedAt;
+        type SetSize = St::SetSize;
+        type UpdatedAt = Set<members::updated_at>;
         type Name = St::Name;
-        type SetSize = Set<members::set_size>;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type SetSize = St::SetSize;
+        type UpdatedAt = St::UpdatedAt;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `updated_at` field
-        pub struct updated_at(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `set_size` field
         pub struct set_size(());
+        ///Marker type for the `updated_at` field
+        pub struct updated_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -464,10 +464,10 @@ where
 impl<S: BosStr, St> SetViewBuilder<S, St>
 where
     St: set_view_state::State,
-    St::UpdatedAt: set_view_state::IsSet,
     St::CreatedAt: set_view_state::IsSet,
-    St::Name: set_view_state::IsSet,
     St::SetSize: set_view_state::IsSet,
+    St::UpdatedAt: set_view_state::IsSet,
+    St::Name: set_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> SetView<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/set/add_values.rs b/crates/jacquard-api/src/tools_ozone/set/add_values.rs
index 06552ea8..dce34212 100644
--- a/crates/jacquard-api/src/tools_ozone/set/add_values.rs
+++ b/crates/jacquard-api/src/tools_ozone/set/add_values.rs
@@ -65,37 +65,37 @@ pub mod add_values_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Values;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Values = Unset;
-    }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Values = St::Values;
+        type Name = Unset;
     }
     ///State transition - sets the `values` field to Set
     pub struct SetValues<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValues<St> {}
     impl<St: State> State for SetValues<St> {
-        type Name = St::Name;
         type Values = Set<members::values>;
+        type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Values = St::Values;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `values` field
         pub struct values(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -165,8 +165,8 @@ where
 impl<S: BosStr, St> AddValuesBuilder<S, St>
 where
     St: add_values_state::State,
-    St::Name: add_values_state::IsSet,
     St::Values: add_values_state::IsSet,
+    St::Name: add_values_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AddValues<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/set/delete_values.rs b/crates/jacquard-api/src/tools_ozone/set/delete_values.rs
index 85f3da40..7831e7ee 100644
--- a/crates/jacquard-api/src/tools_ozone/set/delete_values.rs
+++ b/crates/jacquard-api/src/tools_ozone/set/delete_values.rs
@@ -108,37 +108,37 @@ pub mod delete_values_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Values;
         type Name;
+        type Values;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Values = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `values` field to Set
-    pub struct SetValues<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetValues<St> {}
-    impl<St: State> State for SetValues<St> {
-        type Values = Set<members::values>;
-        type Name = St::Name;
+        type Values = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Values = St::Values;
         type Name = Set<members::name>;
+        type Values = St::Values;
+    }
+    ///State transition - sets the `values` field to Set
+    pub struct SetValues<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetValues<St> {}
+    impl<St: State> State for SetValues<St> {
+        type Name = St::Name;
+        type Values = Set<members::values>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `values` field
-        pub struct values(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `values` field
+        pub struct values(());
     }
 }
 
@@ -208,8 +208,8 @@ where
 impl<S: BosStr, St> DeleteValuesBuilder<S, St>
 where
     St: delete_values_state::State,
-    St::Values: delete_values_state::IsSet,
     St::Name: delete_values_state::IsSet,
+    St::Values: delete_values_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DeleteValues<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/setting.rs b/crates/jacquard-api/src/tools_ozone/setting.rs
index 6f02f193..36e95042 100644
--- a/crates/jacquard-api/src/tools_ozone/setting.rs
+++ b/crates/jacquard-api/src/tools_ozone/setting.rs
@@ -266,10 +266,10 @@ pub mod defs_option_state {
     pub trait State: sealed::Sealed {
         type Key;
         type Value;
-        type CreatedBy;
+        type Did;
         type Scope;
         type LastUpdatedBy;
-        type Did;
+        type CreatedBy;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -277,10 +277,10 @@ pub mod defs_option_state {
     impl State for Empty {
         type Key = Unset;
         type Value = Unset;
-        type CreatedBy = Unset;
+        type Did = Unset;
         type Scope = Unset;
         type LastUpdatedBy = Unset;
-        type Did = Unset;
+        type CreatedBy = Unset;
     }
     ///State transition - sets the `key` field to Set
     pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
@@ -288,10 +288,10 @@ pub mod defs_option_state {
     impl<St: State> State for SetKey<St> {
         type Key = Set<members::key>;
         type Value = St::Value;
-        type CreatedBy = St::CreatedBy;
+        type Did = St::Did;
         type Scope = St::Scope;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type Did = St::Did;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
@@ -299,21 +299,21 @@ pub mod defs_option_state {
     impl<St: State> State for SetValue<St> {
         type Key = St::Key;
         type Value = Set<members::value>;
-        type CreatedBy = St::CreatedBy;
+        type Did = St::Did;
         type Scope = St::Scope;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type Did = St::Did;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `created_by` field to Set
-    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
-    impl<St: State> State for SetCreatedBy<St> {
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
         type Key = St::Key;
         type Value = St::Value;
-        type CreatedBy = Set<members::created_by>;
+        type Did = Set<members::did>;
         type Scope = St::Scope;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type Did = St::Did;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `scope` field to Set
     pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
@@ -321,10 +321,10 @@ pub mod defs_option_state {
     impl<St: State> State for SetScope<St> {
         type Key = St::Key;
         type Value = St::Value;
-        type CreatedBy = St::CreatedBy;
+        type Did = St::Did;
         type Scope = Set<members::scope>;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type Did = St::Did;
+        type CreatedBy = St::CreatedBy;
     }
     ///State transition - sets the `last_updated_by` field to Set
     pub struct SetLastUpdatedBy<St: State = Empty>(PhantomData<fn() -> St>);
@@ -332,21 +332,21 @@ pub mod defs_option_state {
     impl<St: State> State for SetLastUpdatedBy<St> {
         type Key = St::Key;
         type Value = St::Value;
-        type CreatedBy = St::CreatedBy;
+        type Did = St::Did;
         type Scope = St::Scope;
         type LastUpdatedBy = Set<members::last_updated_by>;
-        type Did = St::Did;
+        type CreatedBy = St::CreatedBy;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
+    ///State transition - sets the `created_by` field to Set
+    pub struct SetCreatedBy<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedBy<St> {}
+    impl<St: State> State for SetCreatedBy<St> {
         type Key = St::Key;
         type Value = St::Value;
-        type CreatedBy = St::CreatedBy;
+        type Did = St::Did;
         type Scope = St::Scope;
         type LastUpdatedBy = St::LastUpdatedBy;
-        type Did = Set<members::did>;
+        type CreatedBy = Set<members::created_by>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -355,14 +355,14 @@ pub mod defs_option_state {
         pub struct key(());
         ///Marker type for the `value` field
         pub struct value(());
-        ///Marker type for the `created_by` field
-        pub struct created_by(());
+        ///Marker type for the `did` field
+        pub struct did(());
         ///Marker type for the `scope` field
         pub struct scope(());
         ///Marker type for the `last_updated_by` field
         pub struct last_updated_by(());
-        ///Marker type for the `did` field
-        pub struct did(());
+        ///Marker type for the `created_by` field
+        pub struct created_by(());
     }
 }
 
@@ -579,10 +579,10 @@ where
     St: defs_option_state::State,
     St::Key: defs_option_state::IsSet,
     St::Value: defs_option_state::IsSet,
-    St::CreatedBy: defs_option_state::IsSet,
+    St::Did: defs_option_state::IsSet,
     St::Scope: defs_option_state::IsSet,
     St::LastUpdatedBy: defs_option_state::IsSet,
-    St::Did: defs_option_state::IsSet,
+    St::CreatedBy: defs_option_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DefsOption<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/setting/remove_options.rs b/crates/jacquard-api/src/tools_ozone/setting/remove_options.rs
index fae6a708..bb6d4922 100644
--- a/crates/jacquard-api/src/tools_ozone/setting/remove_options.rs
+++ b/crates/jacquard-api/src/tools_ozone/setting/remove_options.rs
@@ -150,37 +150,37 @@ pub mod remove_options_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Keys;
         type Scope;
+        type Keys;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Keys = Unset;
         type Scope = Unset;
-    }
-    ///State transition - sets the `keys` field to Set
-    pub struct SetKeys<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKeys<St> {}
-    impl<St: State> State for SetKeys<St> {
-        type Keys = Set<members::keys>;
-        type Scope = St::Scope;
+        type Keys = Unset;
     }
     ///State transition - sets the `scope` field to Set
     pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScope<St> {}
     impl<St: State> State for SetScope<St> {
-        type Keys = St::Keys;
         type Scope = Set<members::scope>;
+        type Keys = St::Keys;
+    }
+    ///State transition - sets the `keys` field to Set
+    pub struct SetKeys<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKeys<St> {}
+    impl<St: State> State for SetKeys<St> {
+        type Scope = St::Scope;
+        type Keys = Set<members::keys>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `keys` field
-        pub struct keys(());
         ///Marker type for the `scope` field
         pub struct scope(());
+        ///Marker type for the `keys` field
+        pub struct keys(());
     }
 }
 
@@ -250,8 +250,8 @@ where
 impl<S: BosStr, St> RemoveOptionsBuilder<S, St>
 where
     St: remove_options_state::State,
-    St::Keys: remove_options_state::IsSet,
     St::Scope: remove_options_state::IsSet,
+    St::Keys: remove_options_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> RemoveOptions<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs b/crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs
index eda0d549..51407547 100644
--- a/crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs
+++ b/crates/jacquard-api/src/tools_ozone/setting/upsert_option.rs
@@ -250,50 +250,50 @@ pub mod upsert_option_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Scope;
-        type Key;
         type Value;
+        type Key;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Scope = Unset;
-        type Key = Unset;
         type Value = Unset;
+        type Key = Unset;
     }
     ///State transition - sets the `scope` field to Set
     pub struct SetScope<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetScope<St> {}
     impl<St: State> State for SetScope<St> {
         type Scope = Set<members::scope>;
-        type Key = St::Key;
-        type Value = St::Value;
-    }
-    ///State transition - sets the `key` field to Set
-    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetKey<St> {}
-    impl<St: State> State for SetKey<St> {
-        type Scope = St::Scope;
-        type Key = Set<members::key>;
         type Value = St::Value;
+        type Key = St::Key;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
         type Scope = St::Scope;
-        type Key = St::Key;
         type Value = Set<members::value>;
+        type Key = St::Key;
+    }
+    ///State transition - sets the `key` field to Set
+    pub struct SetKey<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetKey<St> {}
+    impl<St: State> State for SetKey<St> {
+        type Scope = St::Scope;
+        type Value = St::Value;
+        type Key = Set<members::key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `scope` field
         pub struct scope(());
-        ///Marker type for the `key` field
-        pub struct key(());
         ///Marker type for the `value` field
         pub struct value(());
+        ///Marker type for the `key` field
+        pub struct key(());
     }
 }
 
@@ -421,8 +421,8 @@ impl<S: BosStr, St> UpsertOptionBuilder<S, St>
 where
     St: upsert_option_state::State,
     St::Scope: upsert_option_state::IsSet,
-    St::Key: upsert_option_state::IsSet,
     St::Value: upsert_option_state::IsSet,
+    St::Key: upsert_option_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> UpsertOption<S> {
diff --git a/crates/jacquard-api/src/tools_ozone/verification.rs b/crates/jacquard-api/src/tools_ozone/verification.rs
index 13aebf02..baeae9ec 100644
--- a/crates/jacquard-api/src/tools_ozone/verification.rs
+++ b/crates/jacquard-api/src/tools_ozone/verification.rs
@@ -116,105 +116,105 @@ pub mod verification_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Issuer;
         type Uri;
         type Subject;
         type Handle;
-        type CreatedAt;
+        type Issuer;
         type DisplayName;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Issuer = Unset;
         type Uri = Unset;
         type Subject = Unset;
         type Handle = Unset;
-        type CreatedAt = Unset;
+        type Issuer = Unset;
         type DisplayName = Unset;
-    }
-    ///State transition - sets the `issuer` field to Set
-    pub struct SetIssuer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetIssuer<St> {}
-    impl<St: State> State for SetIssuer<St> {
-        type Issuer = Set<members::issuer>;
-        type Uri = St::Uri;
-        type Subject = St::Subject;
-        type Handle = St::Handle;
-        type CreatedAt = St::CreatedAt;
-        type DisplayName = St::DisplayName;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Issuer = St::Issuer;
         type Uri = Set<members::uri>;
         type Subject = St::Subject;
         type Handle = St::Handle;
-        type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
         type DisplayName = St::DisplayName;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `subject` field to Set
     pub struct SetSubject<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSubject<St> {}
     impl<St: State> State for SetSubject<St> {
-        type Issuer = St::Issuer;
         type Uri = St::Uri;
         type Subject = Set<members::subject>;
         type Handle = St::Handle;
-        type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
         type DisplayName = St::DisplayName;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `handle` field to Set
     pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHandle<St> {}
     impl<St: State> State for SetHandle<St> {
-        type Issuer = St::Issuer;
         type Uri = St::Uri;
         type Subject = St::Subject;
         type Handle = Set<members::handle>;
-        type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
         type DisplayName = St::DisplayName;
+        type CreatedAt = St::CreatedAt;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type Issuer = St::Issuer;
+    ///State transition - sets the `issuer` field to Set
+    pub struct SetIssuer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetIssuer<St> {}
+    impl<St: State> State for SetIssuer<St> {
         type Uri = St::Uri;
         type Subject = St::Subject;
         type Handle = St::Handle;
-        type CreatedAt = Set<members::created_at>;
+        type Issuer = Set<members::issuer>;
         type DisplayName = St::DisplayName;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `display_name` field to Set
     pub struct SetDisplayName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDisplayName<St> {}
     impl<St: State> State for SetDisplayName<St> {
-        type Issuer = St::Issuer;
         type Uri = St::Uri;
         type Subject = St::Subject;
         type Handle = St::Handle;
-        type CreatedAt = St::CreatedAt;
+        type Issuer = St::Issuer;
         type DisplayName = Set<members::display_name>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Uri = St::Uri;
+        type Subject = St::Subject;
+        type Handle = St::Handle;
+        type Issuer = St::Issuer;
+        type DisplayName = St::DisplayName;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `issuer` field
-        pub struct issuer(());
         ///Marker type for the `uri` field
         pub struct uri(());
         ///Marker type for the `subject` field
         pub struct subject(());
         ///Marker type for the `handle` field
         pub struct handle(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `issuer` field
+        pub struct issuer(());
         ///Marker type for the `display_name` field
         pub struct display_name(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -491,12 +491,12 @@ where
 impl<S: BosStr, St> VerificationViewBuilder<S, St>
 where
     St: verification_view_state::State,
-    St::Issuer: verification_view_state::IsSet,
     St::Uri: verification_view_state::IsSet,
     St::Subject: verification_view_state::IsSet,
     St::Handle: verification_view_state::IsSet,
-    St::CreatedAt: verification_view_state::IsSet,
+    St::Issuer: verification_view_state::IsSet,
     St::DisplayName: verification_view_state::IsSet,
+    St::CreatedAt: verification_view_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> VerificationView<S> {
diff --git a/crates/jacquard-api/src/uk_ewancroft/kofi/supporter.rs b/crates/jacquard-api/src/uk_ewancroft/kofi/supporter.rs
index 47b41719..42416b81 100644
--- a/crates/jacquard-api/src/uk_ewancroft/kofi/supporter.rs
+++ b/crates/jacquard-api/src/uk_ewancroft/kofi/supporter.rs
@@ -117,37 +117,37 @@ pub mod supporter_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Type;
         type Name;
+        type Type;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Type = Unset;
         type Name = Unset;
-    }
-    ///State transition - sets the `type` field to Set
-    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetType<St> {}
-    impl<St: State> State for SetType<St> {
-        type Type = Set<members::r#type>;
-        type Name = St::Name;
+        type Type = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type Type = St::Type;
         type Name = Set<members::name>;
+        type Type = St::Type;
+    }
+    ///State transition - sets the `type` field to Set
+    pub struct SetType<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetType<St> {}
+    impl<St: State> State for SetType<St> {
+        type Name = St::Name;
+        type Type = Set<members::r#type>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `type` field
-        pub struct r#type(());
         ///Marker type for the `name` field
         pub struct name(());
+        ///Marker type for the `type` field
+        pub struct r#type(());
     }
 }
 
@@ -230,8 +230,8 @@ where
 impl<S: BosStr, St> SupporterBuilder<S, St>
 where
     St: supporter_state::State,
-    St::Type: supporter_state::IsSet,
     St::Name: supporter_state::IsSet,
+    St::Type: supporter_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Supporter<S> {
diff --git a/crates/jacquard-api/src/uk_skyblur/post.rs b/crates/jacquard-api/src/uk_skyblur/post.rs
index 79e6b42a..f02306e2 100644
--- a/crates/jacquard-api/src/uk_skyblur/post.rs
+++ b/crates/jacquard-api/src/uk_skyblur/post.rs
@@ -202,66 +202,66 @@ pub mod post_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Visibility;
+        type Uri;
         type Text;
         type CreatedAt;
-        type Uri;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Visibility = Unset;
+        type Uri = Unset;
         type Text = Unset;
         type CreatedAt = Unset;
-        type Uri = Unset;
     }
     ///State transition - sets the `visibility` field to Set
     pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVisibility<St> {}
     impl<St: State> State for SetVisibility<St> {
         type Visibility = Set<members::visibility>;
+        type Uri = St::Uri;
+        type Text = St::Text;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `uri` field to Set
+    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetUri<St> {}
+    impl<St: State> State for SetUri<St> {
+        type Visibility = St::Visibility;
+        type Uri = Set<members::uri>;
         type Text = St::Text;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
         type Visibility = St::Visibility;
+        type Uri = St::Uri;
         type Text = Set<members::text>;
         type CreatedAt = St::CreatedAt;
-        type Uri = St::Uri;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Visibility = St::Visibility;
-        type Text = St::Text;
-        type CreatedAt = Set<members::created_at>;
         type Uri = St::Uri;
-    }
-    ///State transition - sets the `uri` field to Set
-    pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetUri<St> {}
-    impl<St: State> State for SetUri<St> {
-        type Visibility = St::Visibility;
         type Text = St::Text;
-        type CreatedAt = St::CreatedAt;
-        type Uri = Set<members::uri>;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `visibility` field
         pub struct visibility(());
+        ///Marker type for the `uri` field
+        pub struct uri(());
         ///Marker type for the `text` field
         pub struct text(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `uri` field
-        pub struct uri(());
     }
 }
 
@@ -403,9 +403,9 @@ impl<S: BosStr, St> PostBuilder<S, St>
 where
     St: post_state::State,
     St::Visibility: post_state::IsSet,
+    St::Uri: post_state::IsSet,
     St::Text: post_state::IsSet,
     St::CreatedAt: post_state::IsSet,
-    St::Uri: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/uk_skyblur/post/decrypt_by_cid.rs b/crates/jacquard-api/src/uk_skyblur/post/decrypt_by_cid.rs
index 43796228..c34feb28 100644
--- a/crates/jacquard-api/src/uk_skyblur/post/decrypt_by_cid.rs
+++ b/crates/jacquard-api/src/uk_skyblur/post/decrypt_by_cid.rs
@@ -80,67 +80,67 @@ pub mod decrypt_by_cid_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Pds;
-        type Cid;
-        type Password;
         type Repo;
+        type Password;
+        type Cid;
+        type Pds;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Pds = Unset;
-        type Cid = Unset;
-        type Password = Unset;
         type Repo = Unset;
+        type Password = Unset;
+        type Cid = Unset;
+        type Pds = Unset;
     }
-    ///State transition - sets the `pds` field to Set
-    pub struct SetPds<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetPds<St> {}
-    impl<St: State> State for SetPds<St> {
-        type Pds = Set<members::pds>;
-        type Cid = St::Cid;
+    ///State transition - sets the `repo` field to Set
+    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetRepo<St> {}
+    impl<St: State> State for SetRepo<St> {
+        type Repo = Set<members::repo>;
         type Password = St::Password;
-        type Repo = St::Repo;
-    }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
+        type Cid = St::Cid;
         type Pds = St::Pds;
-        type Cid = Set<members::cid>;
-        type Password = St::Password;
-        type Repo = St::Repo;
     }
     ///State transition - sets the `password` field to Set
     pub struct SetPassword<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetPassword<St> {}
     impl<St: State> State for SetPassword<St> {
-        type Pds = St::Pds;
-        type Cid = St::Cid;
-        type Password = Set<members::password>;
         type Repo = St::Repo;
+        type Password = Set<members::password>;
+        type Cid = St::Cid;
+        type Pds = St::Pds;
     }
-    ///State transition - sets the `repo` field to Set
-    pub struct SetRepo<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetRepo<St> {}
-    impl<St: State> State for SetRepo<St> {
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Repo = St::Repo;
+        type Password = St::Password;
+        type Cid = Set<members::cid>;
         type Pds = St::Pds;
-        type Cid = St::Cid;
+    }
+    ///State transition - sets the `pds` field to Set
+    pub struct SetPds<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetPds<St> {}
+    impl<St: State> State for SetPds<St> {
+        type Repo = St::Repo;
         type Password = St::Password;
-        type Repo = Set<members::repo>;
+        type Cid = St::Cid;
+        type Pds = Set<members::pds>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `pds` field
-        pub struct pds(());
-        ///Marker type for the `cid` field
-        pub struct cid(());
-        ///Marker type for the `password` field
-        pub struct password(());
         ///Marker type for the `repo` field
         pub struct repo(());
+        ///Marker type for the `password` field
+        pub struct password(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
+        ///Marker type for the `pds` field
+        pub struct pds(());
     }
 }
 
@@ -248,10 +248,10 @@ where
 impl<S: BosStr, St> DecryptByCidBuilder<S, St>
 where
     St: decrypt_by_cid_state::State,
-    St::Pds: decrypt_by_cid_state::IsSet,
-    St::Cid: decrypt_by_cid_state::IsSet,
-    St::Password: decrypt_by_cid_state::IsSet,
     St::Repo: decrypt_by_cid_state::IsSet,
+    St::Password: decrypt_by_cid_state::IsSet,
+    St::Cid: decrypt_by_cid_state::IsSet,
+    St::Pds: decrypt_by_cid_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> DecryptByCid<S> {
diff --git a/crates/jacquard-api/src/uk_skyblur/post/store.rs b/crates/jacquard-api/src/uk_skyblur/post/store.rs
index 96a0e70f..036133dd 100644
--- a/crates/jacquard-api/src/uk_skyblur/post/store.rs
+++ b/crates/jacquard-api/src/uk_skyblur/post/store.rs
@@ -79,51 +79,51 @@ pub mod store_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type Text;
         type Visibility;
         type Uri;
-        type Text;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type Text = Unset;
         type Visibility = Unset;
         type Uri = Unset;
-        type Text = Unset;
+    }
+    ///State transition - sets the `text` field to Set
+    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetText<St> {}
+    impl<St: State> State for SetText<St> {
+        type Text = Set<members::text>;
+        type Visibility = St::Visibility;
+        type Uri = St::Uri;
     }
     ///State transition - sets the `visibility` field to Set
     pub struct SetVisibility<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetVisibility<St> {}
     impl<St: State> State for SetVisibility<St> {
+        type Text = St::Text;
         type Visibility = Set<members::visibility>;
         type Uri = St::Uri;
-        type Text = St::Text;
     }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Visibility = St::Visibility;
-        type Uri = Set<members::uri>;
         type Text = St::Text;
-    }
-    ///State transition - sets the `text` field to Set
-    pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetText<St> {}
-    impl<St: State> State for SetText<St> {
         type Visibility = St::Visibility;
-        type Uri = St::Uri;
-        type Text = Set<members::text>;
+        type Uri = Set<members::uri>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `text` field
+        pub struct text(());
         ///Marker type for the `visibility` field
         pub struct visibility(());
         ///Marker type for the `uri` field
         pub struct uri(());
-        ///Marker type for the `text` field
-        pub struct text(());
     }
 }
 
@@ -225,9 +225,9 @@ where
 impl<S: BosStr, St> StoreBuilder<S, St>
 where
     St: store_state::State,
+    St::Text: store_state::IsSet,
     St::Visibility: store_state::IsSet,
     St::Uri: store_state::IsSet,
-    St::Text: store_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Store<S> {
diff --git a/crates/jacquard-api/src/us_polhem/blog.rs b/crates/jacquard-api/src/us_polhem/blog.rs
index 5213eb8f..49de91ff 100644
--- a/crates/jacquard-api/src/us_polhem/blog.rs
+++ b/crates/jacquard-api/src/us_polhem/blog.rs
@@ -84,37 +84,37 @@ pub mod aspect_ratio_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Width;
         type Height;
+        type Width;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Width = Unset;
         type Height = Unset;
-    }
-    ///State transition - sets the `width` field to Set
-    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWidth<St> {}
-    impl<St: State> State for SetWidth<St> {
-        type Width = Set<members::width>;
-        type Height = St::Height;
+        type Width = Unset;
     }
     ///State transition - sets the `height` field to Set
     pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetHeight<St> {}
     impl<St: State> State for SetHeight<St> {
-        type Width = St::Width;
         type Height = Set<members::height>;
+        type Width = St::Width;
+    }
+    ///State transition - sets the `width` field to Set
+    pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWidth<St> {}
+    impl<St: State> State for SetWidth<St> {
+        type Height = St::Height;
+        type Width = Set<members::width>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `width` field
-        pub struct width(());
         ///Marker type for the `height` field
         pub struct height(());
+        ///Marker type for the `width` field
+        pub struct width(());
     }
 }
 
@@ -184,8 +184,8 @@ where
 impl<S: BosStr, St> AspectRatioBuilder<S, St>
 where
     St: aspect_ratio_state::State,
-    St::Width: aspect_ratio_state::IsSet,
     St::Height: aspect_ratio_state::IsSet,
+    St::Width: aspect_ratio_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> AspectRatio<S> {
diff --git a/crates/jacquard-api/src/us_polhem/blog/content.rs b/crates/jacquard-api/src/us_polhem/blog/content.rs
index f23f8964..7fe469e5 100644
--- a/crates/jacquard-api/src/us_polhem/blog/content.rs
+++ b/crates/jacquard-api/src/us_polhem/blog/content.rs
@@ -138,50 +138,50 @@ pub mod content_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type Slug;
         type Content;
+        type Slug;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type Slug = Unset;
         type Content = Unset;
+        type Slug = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type Slug = St::Slug;
-        type Content = St::Content;
-    }
-    ///State transition - sets the `slug` field to Set
-    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetSlug<St> {}
-    impl<St: State> State for SetSlug<St> {
-        type CreatedAt = St::CreatedAt;
-        type Slug = Set<members::slug>;
         type Content = St::Content;
+        type Slug = St::Slug;
     }
     ///State transition - sets the `content` field to Set
     pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetContent<St> {}
     impl<St: State> State for SetContent<St> {
         type CreatedAt = St::CreatedAt;
-        type Slug = St::Slug;
         type Content = Set<members::content>;
+        type Slug = St::Slug;
+    }
+    ///State transition - sets the `slug` field to Set
+    pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetSlug<St> {}
+    impl<St: State> State for SetSlug<St> {
+        type CreatedAt = St::CreatedAt;
+        type Content = St::Content;
+        type Slug = Set<members::slug>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `slug` field
-        pub struct slug(());
         ///Marker type for the `content` field
         pub struct content(());
+        ///Marker type for the `slug` field
+        pub struct slug(());
     }
 }
 
@@ -284,8 +284,8 @@ impl<S: BosStr, St> ContentBuilder<S, St>
 where
     St: content_state::State,
     St::CreatedAt: content_state::IsSet,
-    St::Slug: content_state::IsSet,
     St::Content: content_state::IsSet,
+    St::Slug: content_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Content<S> {
diff --git a/crates/jacquard-api/src/us_polhem/blog/post.rs b/crates/jacquard-api/src/us_polhem/blog/post.rs
index 42f48da1..12e78fdf 100644
--- a/crates/jacquard-api/src/us_polhem/blog/post.rs
+++ b/crates/jacquard-api/src/us_polhem/blog/post.rs
@@ -176,8 +176,8 @@ pub mod post_state {
     pub trait State: sealed::Sealed {
         type Title;
         type CreatedAt;
-        type Content;
         type Slug;
+        type Content;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -185,8 +185,8 @@ pub mod post_state {
     impl State for Empty {
         type Title = Unset;
         type CreatedAt = Unset;
-        type Content = Unset;
         type Slug = Unset;
+        type Content = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
@@ -194,8 +194,8 @@ pub mod post_state {
     impl<St: State> State for SetTitle<St> {
         type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
         type Slug = St::Slug;
+        type Content = St::Content;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -203,17 +203,8 @@ pub mod post_state {
     impl<St: State> State for SetCreatedAt<St> {
         type Title = St::Title;
         type CreatedAt = Set<members::created_at>;
-        type Content = St::Content;
-        type Slug = St::Slug;
-    }
-    ///State transition - sets the `content` field to Set
-    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContent<St> {}
-    impl<St: State> State for SetContent<St> {
-        type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-        type Content = Set<members::content>;
         type Slug = St::Slug;
+        type Content = St::Content;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
@@ -221,8 +212,17 @@ pub mod post_state {
     impl<St: State> State for SetSlug<St> {
         type Title = St::Title;
         type CreatedAt = St::CreatedAt;
-        type Content = St::Content;
         type Slug = Set<members::slug>;
+        type Content = St::Content;
+    }
+    ///State transition - sets the `content` field to Set
+    pub struct SetContent<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContent<St> {}
+    impl<St: State> State for SetContent<St> {
+        type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
+        type Slug = St::Slug;
+        type Content = Set<members::content>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -231,10 +231,10 @@ pub mod post_state {
         pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `content` field
-        pub struct content(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `content` field
+        pub struct content(());
     }
 }
 
@@ -419,8 +419,8 @@ where
     St: post_state::State,
     St::Title: post_state::IsSet,
     St::CreatedAt: post_state::IsSet,
-    St::Content: post_state::IsSet,
     St::Slug: post_state::IsSet,
+    St::Content: post_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Post<S> {
diff --git a/crates/jacquard-api/src/us_polhem/blog/tag.rs b/crates/jacquard-api/src/us_polhem/blog/tag.rs
index 7b07cd2b..81bc5708 100644
--- a/crates/jacquard-api/src/us_polhem/blog/tag.rs
+++ b/crates/jacquard-api/src/us_polhem/blog/tag.rs
@@ -147,65 +147,65 @@ pub mod tag_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Description;
         type Slug;
+        type Name;
         type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Description = Unset;
         type Slug = Unset;
+        type Name = Unset;
         type CreatedAt = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Description = St::Description;
-        type Slug = St::Slug;
-        type CreatedAt = St::CreatedAt;
-    }
     ///State transition - sets the `description` field to Set
     pub struct SetDescription<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDescription<St> {}
     impl<St: State> State for SetDescription<St> {
-        type Name = St::Name;
         type Description = Set<members::description>;
         type Slug = St::Slug;
+        type Name = St::Name;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `slug` field to Set
     pub struct SetSlug<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSlug<St> {}
     impl<St: State> State for SetSlug<St> {
-        type Name = St::Name;
         type Description = St::Description;
         type Slug = Set<members::slug>;
+        type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Description = St::Description;
+        type Slug = St::Slug;
+        type Name = Set<members::name>;
         type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type Description = St::Description;
         type Slug = St::Slug;
+        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `description` field
         pub struct description(());
         ///Marker type for the `slug` field
         pub struct slug(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
     }
@@ -309,9 +309,9 @@ where
 impl<S: BosStr, St> TagBuilder<S, St>
 where
     St: tag_state::State,
-    St::Name: tag_state::IsSet,
     St::Description: tag_state::IsSet,
     St::Slug: tag_state::IsSet,
+    St::Name: tag_state::IsSet,
     St::CreatedAt: tag_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/win_tomo_x/pushat.rs b/crates/jacquard-api/src/win_tomo_x/pushat.rs
index fdb152e9..292e3ba9 100644
--- a/crates/jacquard-api/src/win_tomo_x/pushat.rs
+++ b/crates/jacquard-api/src/win_tomo_x/pushat.rs
@@ -129,49 +129,49 @@ pub mod device_list_item_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type Id;
+        type Name;
         type Current;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type Id = Unset;
+        type Name = Unset;
         type Current = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type Id = St::Id;
-        type Current = St::Current;
-    }
     ///State transition - sets the `id` field to Set
     pub struct SetId<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetId<St> {}
     impl<St: State> State for SetId<St> {
-        type Name = St::Name;
         type Id = Set<members::id>;
+        type Name = St::Name;
+        type Current = St::Current;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type Id = St::Id;
+        type Name = Set<members::name>;
         type Current = St::Current;
     }
     ///State transition - sets the `current` field to Set
     pub struct SetCurrent<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCurrent<St> {}
     impl<St: State> State for SetCurrent<St> {
-        type Name = St::Name;
         type Id = St::Id;
+        type Name = St::Name;
         type Current = Set<members::current>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `id` field
         pub struct id(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `current` field
         pub struct current(());
     }
@@ -262,8 +262,8 @@ where
 impl<S: BosStr, St> DeviceListItemBuilder<S, St>
 where
     St: device_list_item_state::State,
-    St::Name: device_list_item_state::IsSet,
     St::Id: device_list_item_state::IsSet,
+    St::Name: device_list_item_state::IsSet,
     St::Current: device_list_item_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/world_ptah/temp/action.rs b/crates/jacquard-api/src/world_ptah/temp/action.rs
index 2a78f274..12a92432 100644
--- a/crates/jacquard-api/src/world_ptah/temp/action.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/action.rs
@@ -364,51 +364,51 @@ pub mod action_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type ActorDid;
         type WorldReference;
-        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type ActorDid = Unset;
         type WorldReference = Unset;
-        type CreatedAt = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type ActorDid = St::ActorDid;
+        type WorldReference = St::WorldReference;
     }
     ///State transition - sets the `actor_did` field to Set
     pub struct SetActorDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetActorDid<St> {}
     impl<St: State> State for SetActorDid<St> {
+        type CreatedAt = St::CreatedAt;
         type ActorDid = Set<members::actor_did>;
         type WorldReference = St::WorldReference;
-        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `world_reference` field to Set
     pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorldReference<St> {}
     impl<St: State> State for SetWorldReference<St> {
-        type ActorDid = St::ActorDid;
-        type WorldReference = Set<members::world_reference>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
         type ActorDid = St::ActorDid;
-        type WorldReference = St::WorldReference;
-        type CreatedAt = Set<members::created_at>;
+        type WorldReference = Set<members::world_reference>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `actor_did` field
         pub struct actor_did(());
         ///Marker type for the `world_reference` field
         pub struct world_reference(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
     }
 }
 
@@ -599,9 +599,9 @@ where
 impl<S: BosStr, St> ActionBuilder<S, St>
 where
     St: action_state::State,
+    St::CreatedAt: action_state::IsSet,
     St::ActorDid: action_state::IsSet,
     St::WorldReference: action_state::IsSet,
-    St::CreatedAt: action_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Action<S> {
diff --git a/crates/jacquard-api/src/world_ptah/temp/character.rs b/crates/jacquard-api/src/world_ptah/temp/character.rs
index ab6062aa..bd54af9b 100644
--- a/crates/jacquard-api/src/world_ptah/temp/character.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/character.rs
@@ -876,67 +876,67 @@ pub mod character_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatorDid;
-        type CreatedAt;
         type Name;
         type WorldReference;
+        type CreatorDid;
+        type CreatedAt;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatorDid = Unset;
-        type CreatedAt = Unset;
         type Name = Unset;
         type WorldReference = Unset;
-    }
-    ///State transition - sets the `creator_did` field to Set
-    pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
-    impl<St: State> State for SetCreatorDid<St> {
-        type CreatorDid = Set<members::creator_did>;
-        type CreatedAt = St::CreatedAt;
-        type Name = St::Name;
-        type WorldReference = St::WorldReference;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatorDid = St::CreatorDid;
-        type CreatedAt = Set<members::created_at>;
-        type Name = St::Name;
-        type WorldReference = St::WorldReference;
+        type CreatorDid = Unset;
+        type CreatedAt = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatorDid = St::CreatorDid;
-        type CreatedAt = St::CreatedAt;
         type Name = Set<members::name>;
         type WorldReference = St::WorldReference;
+        type CreatorDid = St::CreatorDid;
+        type CreatedAt = St::CreatedAt;
     }
     ///State transition - sets the `world_reference` field to Set
     pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorldReference<St> {}
     impl<St: State> State for SetWorldReference<St> {
+        type Name = St::Name;
+        type WorldReference = Set<members::world_reference>;
         type CreatorDid = St::CreatorDid;
         type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `creator_did` field to Set
+    pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
+    impl<St: State> State for SetCreatorDid<St> {
         type Name = St::Name;
-        type WorldReference = Set<members::world_reference>;
+        type WorldReference = St::WorldReference;
+        type CreatorDid = Set<members::creator_did>;
+        type CreatedAt = St::CreatedAt;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type WorldReference = St::WorldReference;
+        type CreatorDid = St::CreatorDid;
+        type CreatedAt = Set<members::created_at>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `creator_did` field
-        pub struct creator_did(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `name` field
         pub struct name(());
         ///Marker type for the `world_reference` field
         pub struct world_reference(());
+        ///Marker type for the `creator_did` field
+        pub struct creator_did(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
     }
 }
 
@@ -1192,10 +1192,10 @@ where
 impl<S: BosStr, St> CharacterBuilder<S, St>
 where
     St: character_state::State,
-    St::CreatorDid: character_state::IsSet,
-    St::CreatedAt: character_state::IsSet,
     St::Name: character_state::IsSet,
     St::WorldReference: character_state::IsSet,
+    St::CreatorDid: character_state::IsSet,
+    St::CreatedAt: character_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Character<S> {
diff --git a/crates/jacquard-api/src/world_ptah/temp/contribution.rs b/crates/jacquard-api/src/world_ptah/temp/contribution.rs
index 1495ebc6..7f54c77d 100644
--- a/crates/jacquard-api/src/world_ptah/temp/contribution.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/contribution.rs
@@ -455,50 +455,50 @@ pub mod contribution_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type CreatedAt;
-        type ContributorDid;
         type WorldReference;
+        type ContributorDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type CreatedAt = Unset;
-        type ContributorDid = Unset;
         type WorldReference = Unset;
+        type ContributorDid = Unset;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type CreatedAt = Set<members::created_at>;
-        type ContributorDid = St::ContributorDid;
-        type WorldReference = St::WorldReference;
-    }
-    ///State transition - sets the `contributor_did` field to Set
-    pub struct SetContributorDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetContributorDid<St> {}
-    impl<St: State> State for SetContributorDid<St> {
-        type CreatedAt = St::CreatedAt;
-        type ContributorDid = Set<members::contributor_did>;
         type WorldReference = St::WorldReference;
+        type ContributorDid = St::ContributorDid;
     }
     ///State transition - sets the `world_reference` field to Set
     pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorldReference<St> {}
     impl<St: State> State for SetWorldReference<St> {
         type CreatedAt = St::CreatedAt;
-        type ContributorDid = St::ContributorDid;
         type WorldReference = Set<members::world_reference>;
+        type ContributorDid = St::ContributorDid;
+    }
+    ///State transition - sets the `contributor_did` field to Set
+    pub struct SetContributorDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetContributorDid<St> {}
+    impl<St: State> State for SetContributorDid<St> {
+        type CreatedAt = St::CreatedAt;
+        type WorldReference = St::WorldReference;
+        type ContributorDid = Set<members::contributor_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `contributor_did` field
-        pub struct contributor_did(());
         ///Marker type for the `world_reference` field
         pub struct world_reference(());
+        ///Marker type for the `contributor_did` field
+        pub struct contributor_did(());
     }
 }
 
@@ -694,8 +694,8 @@ impl<S: BosStr, St> ContributionBuilder<S, St>
 where
     St: contribution_state::State,
     St::CreatedAt: contribution_state::IsSet,
-    St::ContributorDid: contribution_state::IsSet,
     St::WorldReference: contribution_state::IsSet,
+    St::ContributorDid: contribution_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Contribution<S> {
diff --git a/crates/jacquard-api/src/world_ptah/temp/event.rs b/crates/jacquard-api/src/world_ptah/temp/event.rs
index b9c67452..20f60a3f 100644
--- a/crates/jacquard-api/src/world_ptah/temp/event.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/event.rs
@@ -616,8 +616,8 @@ pub mod event_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
         type CreatedAt;
+        type Name;
         type WorldReference;
         type CreatorDid;
     }
@@ -625,26 +625,26 @@ pub mod event_state {
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
         type CreatedAt = Unset;
+        type Name = Unset;
         type WorldReference = Unset;
         type CreatorDid = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
-        type CreatedAt = St::CreatedAt;
-        type WorldReference = St::WorldReference;
-        type CreatorDid = St::CreatorDid;
-    }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Name = St::Name;
         type CreatedAt = Set<members::created_at>;
+        type Name = St::Name;
+        type WorldReference = St::WorldReference;
+        type CreatorDid = St::CreatorDid;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
+        type Name = Set<members::name>;
         type WorldReference = St::WorldReference;
         type CreatorDid = St::CreatorDid;
     }
@@ -652,8 +652,8 @@ pub mod event_state {
     pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorldReference<St> {}
     impl<St: State> State for SetWorldReference<St> {
-        type Name = St::Name;
         type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
         type WorldReference = Set<members::world_reference>;
         type CreatorDid = St::CreatorDid;
     }
@@ -661,18 +661,18 @@ pub mod event_state {
     pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
     impl<St: State> State for SetCreatorDid<St> {
-        type Name = St::Name;
         type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
         type WorldReference = St::WorldReference;
         type CreatorDid = Set<members::creator_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `name` field
+        pub struct name(());
         ///Marker type for the `world_reference` field
         pub struct world_reference(());
         ///Marker type for the `creator_did` field
@@ -944,8 +944,8 @@ where
 impl<S: BosStr, St> EventBuilder<S, St>
 where
     St: event_state::State,
-    St::Name: event_state::IsSet,
     St::CreatedAt: event_state::IsSet,
+    St::Name: event_state::IsSet,
     St::WorldReference: event_state::IsSet,
     St::CreatorDid: event_state::IsSet,
 {
diff --git a/crates/jacquard-api/src/world_ptah/temp/location.rs b/crates/jacquard-api/src/world_ptah/temp/location.rs
index a93f2093..289542bb 100644
--- a/crates/jacquard-api/src/world_ptah/temp/location.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/location.rs
@@ -751,67 +751,67 @@ pub mod location_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatorDid;
         type Name;
-        type WorldReference;
         type CreatedAt;
+        type WorldReference;
+        type CreatorDid;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatorDid = Unset;
         type Name = Unset;
-        type WorldReference = Unset;
         type CreatedAt = Unset;
-    }
-    ///State transition - sets the `creator_did` field to Set
-    pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
-    impl<St: State> State for SetCreatorDid<St> {
-        type CreatorDid = Set<members::creator_did>;
-        type Name = St::Name;
-        type WorldReference = St::WorldReference;
-        type CreatedAt = St::CreatedAt;
+        type WorldReference = Unset;
+        type CreatorDid = Unset;
     }
     ///State transition - sets the `name` field to Set
     pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetName<St> {}
     impl<St: State> State for SetName<St> {
-        type CreatorDid = St::CreatorDid;
         type Name = Set<members::name>;
-        type WorldReference = St::WorldReference;
         type CreatedAt = St::CreatedAt;
+        type WorldReference = St::WorldReference;
+        type CreatorDid = St::CreatorDid;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Name = St::Name;
+        type CreatedAt = Set<members::created_at>;
+        type WorldReference = St::WorldReference;
+        type CreatorDid = St::CreatorDid;
     }
     ///State transition - sets the `world_reference` field to Set
     pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetWorldReference<St> {}
     impl<St: State> State for SetWorldReference<St> {
-        type CreatorDid = St::CreatorDid;
         type Name = St::Name;
-        type WorldReference = Set<members::world_reference>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type WorldReference = Set<members::world_reference>;
         type CreatorDid = St::CreatorDid;
+    }
+    ///State transition - sets the `creator_did` field to Set
+    pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
+    impl<St: State> State for SetCreatorDid<St> {
         type Name = St::Name;
+        type CreatedAt = St::CreatedAt;
         type WorldReference = St::WorldReference;
-        type CreatedAt = Set<members::created_at>;
+        type CreatorDid = Set<members::creator_did>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `creator_did` field
-        pub struct creator_did(());
         ///Marker type for the `name` field
         pub struct name(());
-        ///Marker type for the `world_reference` field
-        pub struct world_reference(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `world_reference` field
+        pub struct world_reference(());
+        ///Marker type for the `creator_did` field
+        pub struct creator_did(());
     }
 }
 
@@ -1040,10 +1040,10 @@ where
 impl<S: BosStr, St> LocationBuilder<S, St>
 where
     St: location_state::State,
-    St::CreatorDid: location_state::IsSet,
     St::Name: location_state::IsSet,
-    St::WorldReference: location_state::IsSet,
     St::CreatedAt: location_state::IsSet,
+    St::WorldReference: location_state::IsSet,
+    St::CreatorDid: location_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Location<S> {
diff --git a/crates/jacquard-api/src/world_ptah/temp/lore.rs b/crates/jacquard-api/src/world_ptah/temp/lore.rs
index b51f8396..1ddcff8e 100644
--- a/crates/jacquard-api/src/world_ptah/temp/lore.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/lore.rs
@@ -391,8 +391,8 @@ pub mod lore_state {
     pub trait State: sealed::Sealed {
         type Title;
         type CreatedAt;
-        type WorldReference;
         type CreatorDid;
+        type WorldReference;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
@@ -400,8 +400,8 @@ pub mod lore_state {
     impl State for Empty {
         type Title = Unset;
         type CreatedAt = Unset;
-        type WorldReference = Unset;
         type CreatorDid = Unset;
+        type WorldReference = Unset;
     }
     ///State transition - sets the `title` field to Set
     pub struct SetTitle<St: State = Empty>(PhantomData<fn() -> St>);
@@ -409,8 +409,8 @@ pub mod lore_state {
     impl<St: State> State for SetTitle<St> {
         type Title = Set<members::title>;
         type CreatedAt = St::CreatedAt;
-        type WorldReference = St::WorldReference;
         type CreatorDid = St::CreatorDid;
+        type WorldReference = St::WorldReference;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
@@ -418,17 +418,8 @@ pub mod lore_state {
     impl<St: State> State for SetCreatedAt<St> {
         type Title = St::Title;
         type CreatedAt = Set<members::created_at>;
-        type WorldReference = St::WorldReference;
-        type CreatorDid = St::CreatorDid;
-    }
-    ///State transition - sets the `world_reference` field to Set
-    pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetWorldReference<St> {}
-    impl<St: State> State for SetWorldReference<St> {
-        type Title = St::Title;
-        type CreatedAt = St::CreatedAt;
-        type WorldReference = Set<members::world_reference>;
         type CreatorDid = St::CreatorDid;
+        type WorldReference = St::WorldReference;
     }
     ///State transition - sets the `creator_did` field to Set
     pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
@@ -436,8 +427,17 @@ pub mod lore_state {
     impl<St: State> State for SetCreatorDid<St> {
         type Title = St::Title;
         type CreatedAt = St::CreatedAt;
-        type WorldReference = St::WorldReference;
         type CreatorDid = Set<members::creator_did>;
+        type WorldReference = St::WorldReference;
+    }
+    ///State transition - sets the `world_reference` field to Set
+    pub struct SetWorldReference<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetWorldReference<St> {}
+    impl<St: State> State for SetWorldReference<St> {
+        type Title = St::Title;
+        type CreatedAt = St::CreatedAt;
+        type CreatorDid = St::CreatorDid;
+        type WorldReference = Set<members::world_reference>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
@@ -446,10 +446,10 @@ pub mod lore_state {
         pub struct title(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
-        ///Marker type for the `world_reference` field
-        pub struct world_reference(());
         ///Marker type for the `creator_did` field
         pub struct creator_did(());
+        ///Marker type for the `world_reference` field
+        pub struct world_reference(());
     }
 }
 
@@ -674,8 +674,8 @@ where
     St: lore_state::State,
     St::Title: lore_state::IsSet,
     St::CreatedAt: lore_state::IsSet,
-    St::WorldReference: lore_state::IsSet,
     St::CreatorDid: lore_state::IsSet,
+    St::WorldReference: lore_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Lore<S> {
diff --git a/crates/jacquard-api/src/world_ptah/temp/world.rs b/crates/jacquard-api/src/world_ptah/temp/world.rs
index 6a0aec6f..c214a35b 100644
--- a/crates/jacquard-api/src/world_ptah/temp/world.rs
+++ b/crates/jacquard-api/src/world_ptah/temp/world.rs
@@ -606,51 +606,51 @@ pub mod world_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Name;
-        type CreatorDid;
         type CreatedAt;
+        type CreatorDid;
+        type Name;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Name = Unset;
-        type CreatorDid = Unset;
         type CreatedAt = Unset;
+        type CreatorDid = Unset;
+        type Name = Unset;
     }
-    ///State transition - sets the `name` field to Set
-    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetName<St> {}
-    impl<St: State> State for SetName<St> {
-        type Name = Set<members::name>;
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
         type CreatorDid = St::CreatorDid;
-        type CreatedAt = St::CreatedAt;
+        type Name = St::Name;
     }
     ///State transition - sets the `creator_did` field to Set
     pub struct SetCreatorDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatorDid<St> {}
     impl<St: State> State for SetCreatorDid<St> {
-        type Name = St::Name;
-        type CreatorDid = Set<members::creator_did>;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+        type CreatorDid = Set<members::creator_did>;
         type Name = St::Name;
+    }
+    ///State transition - sets the `name` field to Set
+    pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetName<St> {}
+    impl<St: State> State for SetName<St> {
+        type CreatedAt = St::CreatedAt;
         type CreatorDid = St::CreatorDid;
-        type CreatedAt = Set<members::created_at>;
+        type Name = Set<members::name>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `name` field
-        pub struct name(());
-        ///Marker type for the `creator_did` field
-        pub struct creator_did(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `creator_did` field
+        pub struct creator_did(());
+        ///Marker type for the `name` field
+        pub struct name(());
     }
 }
 
@@ -845,9 +845,9 @@ impl<S: BosStr, St: world_state::State> WorldBuilder<S, St> {
 impl<S: BosStr, St> WorldBuilder<S, St>
 where
     St: world_state::State,
-    St::Name: world_state::IsSet,
-    St::CreatorDid: world_state::IsSet,
     St::CreatedAt: world_state::IsSet,
+    St::CreatorDid: world_state::IsSet,
+    St::Name: world_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> World<S> {
diff --git a/crates/jacquard-api/src/za_co/ciaran/cumulus/market.rs b/crates/jacquard-api/src/za_co/ciaran/cumulus/market.rs
index 3ae2ea7f..0dedf145 100644
--- a/crates/jacquard-api/src/za_co/ciaran/cumulus/market.rs
+++ b/crates/jacquard-api/src/za_co/ciaran/cumulus/market.rs
@@ -125,67 +125,67 @@ pub mod market_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
+        type CreatedAt;
         type ClosesAt;
-        type Question;
         type Liquidity;
-        type CreatedAt;
+        type Question;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
+        type CreatedAt = Unset;
         type ClosesAt = Unset;
-        type Question = Unset;
         type Liquidity = Unset;
-        type CreatedAt = Unset;
+        type Question = Unset;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type CreatedAt = Set<members::created_at>;
+        type ClosesAt = St::ClosesAt;
+        type Liquidity = St::Liquidity;
+        type Question = St::Question;
     }
     ///State transition - sets the `closes_at` field to Set
     pub struct SetClosesAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetClosesAt<St> {}
     impl<St: State> State for SetClosesAt<St> {
-        type ClosesAt = Set<members::closes_at>;
-        type Question = St::Question;
-        type Liquidity = St::Liquidity;
         type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `question` field to Set
-    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetQuestion<St> {}
-    impl<St: State> State for SetQuestion<St> {
-        type ClosesAt = St::ClosesAt;
-        type Question = Set<members::question>;
+        type ClosesAt = Set<members::closes_at>;
         type Liquidity = St::Liquidity;
-        type CreatedAt = St::CreatedAt;
+        type Question = St::Question;
     }
     ///State transition - sets the `liquidity` field to Set
     pub struct SetLiquidity<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetLiquidity<St> {}
     impl<St: State> State for SetLiquidity<St> {
+        type CreatedAt = St::CreatedAt;
         type ClosesAt = St::ClosesAt;
-        type Question = St::Question;
         type Liquidity = Set<members::liquidity>;
-        type CreatedAt = St::CreatedAt;
+        type Question = St::Question;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
+    ///State transition - sets the `question` field to Set
+    pub struct SetQuestion<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetQuestion<St> {}
+    impl<St: State> State for SetQuestion<St> {
+        type CreatedAt = St::CreatedAt;
         type ClosesAt = St::ClosesAt;
-        type Question = St::Question;
         type Liquidity = St::Liquidity;
-        type CreatedAt = Set<members::created_at>;
+        type Question = Set<members::question>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `closes_at` field
         pub struct closes_at(());
-        ///Marker type for the `question` field
-        pub struct question(());
         ///Marker type for the `liquidity` field
         pub struct liquidity(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
+        ///Marker type for the `question` field
+        pub struct question(());
     }
 }
 
@@ -293,10 +293,10 @@ where
 impl<S: BosStr, St> MarketBuilder<S, St>
 where
     St: market_state::State,
+    St::CreatedAt: market_state::IsSet,
     St::ClosesAt: market_state::IsSet,
-    St::Question: market_state::IsSet,
     St::Liquidity: market_state::IsSet,
-    St::CreatedAt: market_state::IsSet,
+    St::Question: market_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Market<S> {
diff --git a/crates/jacquard-api/src/za_co/ciaran/cumulus/resolution.rs b/crates/jacquard-api/src/za_co/ciaran/cumulus/resolution.rs
index 85bdefc1..ad1e1c37 100644
--- a/crates/jacquard-api/src/za_co/ciaran/cumulus/resolution.rs
+++ b/crates/jacquard-api/src/za_co/ciaran/cumulus/resolution.rs
@@ -137,51 +137,51 @@ pub mod resolution_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Market;
-        type CreatedAt;
         type Answer;
+        type CreatedAt;
+        type Market;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Market = Unset;
-        type CreatedAt = Unset;
         type Answer = Unset;
+        type CreatedAt = Unset;
+        type Market = Unset;
     }
-    ///State transition - sets the `market` field to Set
-    pub struct SetMarket<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetMarket<St> {}
-    impl<St: State> State for SetMarket<St> {
-        type Market = Set<members::market>;
+    ///State transition - sets the `answer` field to Set
+    pub struct SetAnswer<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetAnswer<St> {}
+    impl<St: State> State for SetAnswer<St> {
+        type Answer = Set<members::answer>;
         type CreatedAt = St::CreatedAt;
-        type Answer = St::Answer;
+        type Market = St::Market;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
-        type Market = St::Market;
-        type CreatedAt = Set<members::created_at>;
         type Answer = St::Answer;
-    }
-    ///State transition - sets the `answer` field to Set
-    pub struct SetAnswer<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetAnswer<St> {}
-    impl<St: State> State for SetAnswer<St> {
+        type CreatedAt = Set<members::created_at>;
         type Market = St::Market;
+    }
+    ///State transition - sets the `market` field to Set
+    pub struct SetMarket<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetMarket<St> {}
+    impl<St: State> State for SetMarket<St> {
+        type Answer = St::Answer;
         type CreatedAt = St::CreatedAt;
-        type Answer = Set<members::answer>;
+        type Market = Set<members::market>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `market` field
-        pub struct market(());
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `answer` field
         pub struct answer(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
+        ///Marker type for the `market` field
+        pub struct market(());
     }
 }
 
@@ -270,9 +270,9 @@ where
 impl<S: BosStr, St> ResolutionBuilder<S, St>
 where
     St: resolution_state::State,
-    St::Market: resolution_state::IsSet,
-    St::CreatedAt: resolution_state::IsSet,
     St::Answer: resolution_state::IsSet,
+    St::CreatedAt: resolution_state::IsSet,
+    St::Market: resolution_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Resolution<S> {
diff --git a/crates/jacquard-api/src/zip_viruus/chat/message.rs b/crates/jacquard-api/src/zip_viruus/chat/message.rs
index d9d0be3b..c75feabb 100644
--- a/crates/jacquard-api/src/zip_viruus/chat/message.rs
+++ b/crates/jacquard-api/src/zip_viruus/chat/message.rs
@@ -152,50 +152,50 @@ pub mod message_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Text;
-        type Channel;
         type CreatedAt;
+        type Channel;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Text = Unset;
-        type Channel = Unset;
         type CreatedAt = Unset;
+        type Channel = Unset;
     }
     ///State transition - sets the `text` field to Set
     pub struct SetText<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetText<St> {}
     impl<St: State> State for SetText<St> {
         type Text = Set<members::text>;
-        type Channel = St::Channel;
-        type CreatedAt = St::CreatedAt;
-    }
-    ///State transition - sets the `channel` field to Set
-    pub struct SetChannel<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetChannel<St> {}
-    impl<St: State> State for SetChannel<St> {
-        type Text = St::Text;
-        type Channel = Set<members::channel>;
         type CreatedAt = St::CreatedAt;
+        type Channel = St::Channel;
     }
     ///State transition - sets the `created_at` field to Set
     pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
     impl<St: State> State for SetCreatedAt<St> {
         type Text = St::Text;
-        type Channel = St::Channel;
         type CreatedAt = Set<members::created_at>;
+        type Channel = St::Channel;
+    }
+    ///State transition - sets the `channel` field to Set
+    pub struct SetChannel<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetChannel<St> {}
+    impl<St: State> State for SetChannel<St> {
+        type Text = St::Text;
+        type CreatedAt = St::CreatedAt;
+        type Channel = Set<members::channel>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `text` field
         pub struct text(());
-        ///Marker type for the `channel` field
-        pub struct channel(());
         ///Marker type for the `created_at` field
         pub struct created_at(());
+        ///Marker type for the `channel` field
+        pub struct channel(());
     }
 }
 
@@ -285,8 +285,8 @@ impl<S: BosStr, St> MessageBuilder<S, St>
 where
     St: message_state::State,
     St::Text: message_state::IsSet,
-    St::Channel: message_state::IsSet,
     St::CreatedAt: message_state::IsSet,
+    St::Channel: message_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Message<S> {
diff --git a/crates/jacquard-api/src/zone_stratos/actor/enrollment.rs b/crates/jacquard-api/src/zone_stratos/actor/enrollment.rs
index 549eb14a..8057118f 100644
--- a/crates/jacquard-api/src/zone_stratos/actor/enrollment.rs
+++ b/crates/jacquard-api/src/zone_stratos/actor/enrollment.rs
@@ -163,65 +163,65 @@ pub mod enrollment_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type CreatedAt;
         type Service;
         type Attestation;
+        type CreatedAt;
         type SigningKey;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type CreatedAt = Unset;
         type Service = Unset;
         type Attestation = Unset;
+        type CreatedAt = Unset;
         type SigningKey = Unset;
     }
-    ///State transition - sets the `created_at` field to Set
-    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
-    impl<St: State> State for SetCreatedAt<St> {
-        type CreatedAt = Set<members::created_at>;
-        type Service = St::Service;
-        type Attestation = St::Attestation;
-        type SigningKey = St::SigningKey;
-    }
     ///State transition - sets the `service` field to Set
     pub struct SetService<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetService<St> {}
     impl<St: State> State for SetService<St> {
-        type CreatedAt = St::CreatedAt;
         type Service = Set<members::service>;
         type Attestation = St::Attestation;
+        type CreatedAt = St::CreatedAt;
         type SigningKey = St::SigningKey;
     }
     ///State transition - sets the `attestation` field to Set
     pub struct SetAttestation<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAttestation<St> {}
     impl<St: State> State for SetAttestation<St> {
-        type CreatedAt = St::CreatedAt;
         type Service = St::Service;
         type Attestation = Set<members::attestation>;
+        type CreatedAt = St::CreatedAt;
+        type SigningKey = St::SigningKey;
+    }
+    ///State transition - sets the `created_at` field to Set
+    pub struct SetCreatedAt<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCreatedAt<St> {}
+    impl<St: State> State for SetCreatedAt<St> {
+        type Service = St::Service;
+        type Attestation = St::Attestation;
+        type CreatedAt = Set<members::created_at>;
         type SigningKey = St::SigningKey;
     }
     ///State transition - sets the `signing_key` field to Set
     pub struct SetSigningKey<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSigningKey<St> {}
     impl<St: State> State for SetSigningKey<St> {
-        type CreatedAt = St::CreatedAt;
         type Service = St::Service;
         type Attestation = St::Attestation;
+        type CreatedAt = St::CreatedAt;
         type SigningKey = Set<members::signing_key>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `created_at` field
-        pub struct created_at(());
         ///Marker type for the `service` field
         pub struct service(());
         ///Marker type for the `attestation` field
         pub struct attestation(());
+        ///Marker type for the `created_at` field
+        pub struct created_at(());
         ///Marker type for the `signing_key` field
         pub struct signing_key(());
     }
@@ -350,9 +350,9 @@ where
 impl<S: BosStr, St> EnrollmentBuilder<S, St>
 where
     St: enrollment_state::State,
-    St::CreatedAt: enrollment_state::IsSet,
     St::Service: enrollment_state::IsSet,
     St::Attestation: enrollment_state::IsSet,
+    St::CreatedAt: enrollment_state::IsSet,
     St::SigningKey: enrollment_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/zone_stratos/repo/hydrate_records.rs b/crates/jacquard-api/src/zone_stratos/repo/hydrate_records.rs
index a769366f..065c6417 100644
--- a/crates/jacquard-api/src/zone_stratos/repo/hydrate_records.rs
+++ b/crates/jacquard-api/src/zone_stratos/repo/hydrate_records.rs
@@ -213,49 +213,49 @@ pub mod record_view_state {
     }
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
-        type Cid;
         type Uri;
+        type Cid;
         type Value;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
-        type Cid = Unset;
         type Uri = Unset;
+        type Cid = Unset;
         type Value = Unset;
     }
-    ///State transition - sets the `cid` field to Set
-    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetCid<St> {}
-    impl<St: State> State for SetCid<St> {
-        type Cid = Set<members::cid>;
-        type Uri = St::Uri;
-        type Value = St::Value;
-    }
     ///State transition - sets the `uri` field to Set
     pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetUri<St> {}
     impl<St: State> State for SetUri<St> {
-        type Cid = St::Cid;
         type Uri = Set<members::uri>;
+        type Cid = St::Cid;
+        type Value = St::Value;
+    }
+    ///State transition - sets the `cid` field to Set
+    pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetCid<St> {}
+    impl<St: State> State for SetCid<St> {
+        type Uri = St::Uri;
+        type Cid = Set<members::cid>;
         type Value = St::Value;
     }
     ///State transition - sets the `value` field to Set
     pub struct SetValue<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetValue<St> {}
     impl<St: State> State for SetValue<St> {
-        type Cid = St::Cid;
         type Uri = St::Uri;
+        type Cid = St::Cid;
         type Value = Set<members::value>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
-        ///Marker type for the `cid` field
-        pub struct cid(());
         ///Marker type for the `uri` field
         pub struct uri(());
+        ///Marker type for the `cid` field
+        pub struct cid(());
         ///Marker type for the `value` field
         pub struct value(());
     }
@@ -346,8 +346,8 @@ where
 impl<S: BosStr, St> RecordViewBuilder<S, St>
 where
     St: record_view_state::State,
-    St::Cid: record_view_state::IsSet,
     St::Uri: record_view_state::IsSet,
+    St::Cid: record_view_state::IsSet,
     St::Value: record_view_state::IsSet,
 {
     /// Build the final struct.
diff --git a/crates/jacquard-api/src/zone_stratos/repo/import_repo.rs b/crates/jacquard-api/src/zone_stratos/repo/import_repo.rs
index 46ba9324..1fe0f05e 100644
--- a/crates/jacquard-api/src/zone_stratos/repo/import_repo.rs
+++ b/crates/jacquard-api/src/zone_stratos/repo/import_repo.rs
@@ -103,7 +103,7 @@ impl jacquard_common::xrpc::XrpcRequest for ImportRepo {
     type Response = ImportRepoResponse;
     fn encode_body(
         &self,
-        buffer: &mut [u8],
+        buffer: &mut Vec<u8>,
     ) -> Result<(), jacquard_common::xrpc::EncodeError>
     where
         Self: Serialize,
diff --git a/crates/jacquard-api/src/zone_stratos/sync/subscribe_records.rs b/crates/jacquard-api/src/zone_stratos/sync/subscribe_records.rs
index 27b238e2..b444523f 100644
--- a/crates/jacquard-api/src/zone_stratos/sync/subscribe_records.rs
+++ b/crates/jacquard-api/src/zone_stratos/sync/subscribe_records.rs
@@ -605,84 +605,84 @@ pub mod commit_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Seq;
-        type Time;
         type Rev;
-        type Ops;
         type Did;
+        type Ops;
+        type Time;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Seq = Unset;
-        type Time = Unset;
         type Rev = Unset;
-        type Ops = Unset;
         type Did = Unset;
+        type Ops = Unset;
+        type Time = Unset;
     }
     ///State transition - sets the `seq` field to Set
     pub struct SetSeq<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetSeq<St> {}
     impl<St: State> State for SetSeq<St> {
         type Seq = Set<members::seq>;
-        type Time = St::Time;
         type Rev = St::Rev;
-        type Ops = St::Ops;
         type Did = St::Did;
-    }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
-        type Seq = St::Seq;
-        type Time = Set<members::time>;
-        type Rev = St::Rev;
         type Ops = St::Ops;
-        type Did = St::Did;
+        type Time = St::Time;
     }
     ///State transition - sets the `rev` field to Set
     pub struct SetRev<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetRev<St> {}
     impl<St: State> State for SetRev<St> {
         type Seq = St::Seq;
-        type Time = St::Time;
         type Rev = Set<members::rev>;
-        type Ops = St::Ops;
         type Did = St::Did;
+        type Ops = St::Ops;
+        type Time = St::Time;
+    }
+    ///State transition - sets the `did` field to Set
+    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetDid<St> {}
+    impl<St: State> State for SetDid<St> {
+        type Seq = St::Seq;
+        type Rev = St::Rev;
+        type Did = Set<members::did>;
+        type Ops = St::Ops;
+        type Time = St::Time;
     }
     ///State transition - sets the `ops` field to Set
     pub struct SetOps<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetOps<St> {}
     impl<St: State> State for SetOps<St> {
         type Seq = St::Seq;
-        type Time = St::Time;
         type Rev = St::Rev;
-        type Ops = Set<members::ops>;
         type Did = St::Did;
+        type Ops = Set<members::ops>;
+        type Time = St::Time;
     }
-    ///State transition - sets the `did` field to Set
-    pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetDid<St> {}
-    impl<St: State> State for SetDid<St> {
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
         type Seq = St::Seq;
-        type Time = St::Time;
         type Rev = St::Rev;
+        type Did = St::Did;
         type Ops = St::Ops;
-        type Did = Set<members::did>;
+        type Time = Set<members::time>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `seq` field
         pub struct seq(());
-        ///Marker type for the `time` field
-        pub struct time(());
         ///Marker type for the `rev` field
         pub struct rev(());
-        ///Marker type for the `ops` field
-        pub struct ops(());
         ///Marker type for the `did` field
         pub struct did(());
+        ///Marker type for the `ops` field
+        pub struct ops(());
+        ///Marker type for the `time` field
+        pub struct time(());
     }
 }
 
@@ -816,10 +816,10 @@ impl<S: BosStr, St> CommitBuilder<S, St>
 where
     St: commit_state::State,
     St::Seq: commit_state::IsSet,
-    St::Time: commit_state::IsSet,
     St::Rev: commit_state::IsSet,
-    St::Ops: commit_state::IsSet,
     St::Did: commit_state::IsSet,
+    St::Ops: commit_state::IsSet,
+    St::Time: commit_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Commit<S> {
@@ -1165,50 +1165,50 @@ pub mod enrollment_state {
     /// State trait tracking which required fields have been set
     pub trait State: sealed::Sealed {
         type Did;
-        type Time;
         type Action;
+        type Time;
     }
     /// Empty state - all required fields are unset
     pub struct Empty(());
     impl sealed::Sealed for Empty {}
     impl State for Empty {
         type Did = Unset;
-        type Time = Unset;
         type Action = Unset;
+        type Time = Unset;
     }
     ///State transition - sets the `did` field to Set
     pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetDid<St> {}
     impl<St: State> State for SetDid<St> {
         type Did = Set<members::did>;
-        type Time = St::Time;
-        type Action = St::Action;
-    }
-    ///State transition - sets the `time` field to Set
-    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
-    impl<St: State> sealed::Sealed for SetTime<St> {}
-    impl<St: State> State for SetTime<St> {
-        type Did = St::Did;
-        type Time = Set<members::time>;
         type Action = St::Action;
+        type Time = St::Time;
     }
     ///State transition - sets the `action` field to Set
     pub struct SetAction<St: State = Empty>(PhantomData<fn() -> St>);
     impl<St: State> sealed::Sealed for SetAction<St> {}
     impl<St: State> State for SetAction<St> {
         type Did = St::Did;
-        type Time = St::Time;
         type Action = Set<members::action>;
+        type Time = St::Time;
+    }
+    ///State transition - sets the `time` field to Set
+    pub struct SetTime<St: State = Empty>(PhantomData<fn() -> St>);
+    impl<St: State> sealed::Sealed for SetTime<St> {}
+    impl<St: State> State for SetTime<St> {
+        type Did = St::Did;
+        type Action = St::Action;
+        type Time = Set<members::time>;
     }
     /// Marker types for field names
     #[allow(non_camel_case_types)]
     pub mod members {
         ///Marker type for the `did` field
         pub struct did(());
-        ///Marker type for the `time` field
-        pub struct time(());
         ///Marker type for the `action` field
         pub struct action(());
+        ///Marker type for the `time` field
+        pub struct time(());
     }
 }
 
@@ -1330,8 +1330,8 @@ impl<S: BosStr, St> EnrollmentBuilder<S, St>
 where
     St: enrollment_state::State,
     St::Did: enrollment_state::IsSet,
-    St::Time: enrollment_state::IsSet,
     St::Action: enrollment_state::IsSet,
+    St::Time: enrollment_state::IsSet,
 {
     /// Build the final struct.
     pub fn build(self) -> Enrollment<S> {
diff --git a/crates/jacquard-axum/src/lib.rs b/crates/jacquard-axum/src/lib.rs
index 455d98cc..3029aaf9 100644
--- a/crates/jacquard-axum/src/lib.rs
+++ b/crates/jacquard-axum/src/lib.rs
@@ -57,9 +57,10 @@ use axum::{
     response::{IntoResponse, Response},
 };
 use jacquard::{
-    BosStr, IntoStatic,
+    BosStr, CowStr, IntoStatic,
     xrpc::{XrpcEndpoint, XrpcError, XrpcMethod, XrpcRequest},
 };
+use serde::Deserialize;
 use serde_json::json;
 
 /// Axum extractor for XRPC requests
@@ -68,18 +69,17 @@ use serde_json::json;
 /// and returns the owned (`'static`) request type ready for handler logic.
 pub struct ExtractXrpc<E: XrpcEndpoint, S: BosStr>(pub E::Request<S>);
 
-impl<S, R, B> FromRequest<S> for ExtractXrpc<R, B>
+impl<R> FromRequest<CowStr<'_>> for ExtractXrpc<R, CowStr<'static>>
 where
-    S: BosStr + Send + Sync,
-    B: BosStr,
     R: XrpcEndpoint,
-    R::Request<S>: IntoStatic<Output = R::Request<B>>,
+    for<'de> R::Request<CowStr<'de>>: Deserialize<'de>,
+    for<'a> R::Request<CowStr<'a>>: IntoStatic<Output = R::Request<CowStr<'static>>>,
 {
     type Rejection = Response;
 
     fn from_request(
         req: Request,
-        state: &S,
+        state: &CowStr<'_>,
     ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
         async {
             match R::METHOD {
@@ -89,7 +89,7 @@ where
                         .map_err(IntoResponse::into_response)?;
                     let decoded = R::Request::decode_body(&body);
                     match decoded {
-                        Ok(value) => Ok(ExtractXrpc(*value.into_static())),
+                        Ok(value) => Ok(ExtractXrpc(value.into_static())),
                         Err(err) => Err((
                             StatusCode::BAD_REQUEST,
                             Json(json!({
@@ -103,17 +103,19 @@ where
                 XrpcMethod::Query => {
                     if let Some(path_query) = req.uri().path_and_query() {
                         let query = path_query.query().unwrap_or("");
-                        let value: R::Request<S> =
-                            serde_html_form::from_str::<R::Request<S>>(query).map_err(|e| {
-                                (
-                                    StatusCode::BAD_REQUEST,
-                                    Json(json!({
-                                        "error": "InvalidRequest",
-                                        "message": format!("failed to decode request: {}", e)
-                                    })),
-                                )
-                                    .into_response()
-                            })?;
+                        let value: R::Request<CowStr<'_>> = serde_html_form::from_str::<
+                            R::Request<CowStr<'_>>,
+                        >(query)
+                        .map_err(|e| {
+                            (
+                                StatusCode::BAD_REQUEST,
+                                Json(json!({
+                                    "error": "InvalidRequest",
+                                    "message": format!("failed to decode request: {}", e)
+                                })),
+                            )
+                                .into_response()
+                        })?;
                         Ok(ExtractXrpc(value.into_static()))
                     } else {
                         Err((
diff --git a/crates/jacquard-axum/src/service_auth.rs b/crates/jacquard-axum/src/service_auth.rs
index 6caa9a63..af8f7fbb 100644
--- a/crates/jacquard-axum/src/service_auth.rs
+++ b/crates/jacquard-axum/src/service_auth.rs
@@ -44,6 +44,7 @@ use axum::{
     middleware::Next,
     response::{IntoResponse, Response},
 };
+use jacquard::deps::smol_str::SmolStr;
 use jacquard_common::{
     CowStr, IntoStatic,
     service_auth::{self, PublicKey},
@@ -527,7 +528,7 @@ where
             service_auth::verify_signature(&parsed, &signing_key)?;
 
             // Now validate claims (audience, expiration, etc.)
-            claims.validate(state.service_did())?;
+            claims.validate(&state.service_did())?;
 
             // Check method binding if required
             if state.require_lxm() && claims.lxm.is_none() {
@@ -549,7 +550,7 @@ where
 ///
 /// This looks for a key with type "atproto" or the first available key
 /// if no atproto-specific key is found.
-fn extract_signing_key(methods: &[VerificationMethod<SmolStr>]) -> Option<PublicKey> {
+fn extract_signing_key(methods: &[VerificationMethod<CowStr<'_>>]) -> Option<PublicKey> {
     // First try to find an atproto-specific key
     let atproto_method = methods
         .iter()
diff --git a/crates/jacquard-common/src/xrpc.rs b/crates/jacquard-common/src/xrpc.rs
index 32d89bb8..0c756e04 100644
--- a/crates/jacquard-common/src/xrpc.rs
+++ b/crates/jacquard-common/src/xrpc.rs
@@ -146,7 +146,7 @@ pub trait XrpcRequest {
     /// Encode the request body for procedures.
     ///
     /// Default implementation serializes to JSON. Override for non-JSON encodings.
-    fn encode_body(&self, buffer: &mut [u8]) -> Result<(), EncodeError>
+    fn encode_body(&self, buffer: &mut Vec<u8>) -> Result<(), EncodeError>
     where
         Self: Serialize,
     {
diff --git a/crates/jacquard-lexicon/src/codegen/xrpc.rs b/crates/jacquard-lexicon/src/codegen/xrpc.rs
index dba08ad1..5545bc19 100644
--- a/crates/jacquard-lexicon/src/codegen/xrpc.rs
+++ b/crates/jacquard-lexicon/src/codegen/xrpc.rs
@@ -1290,7 +1290,7 @@ impl<'c> CodeGenerator<'c> {
         // Generate encode_body() method for binary inputs
         let encode_body_method = if is_binary_input {
             quote! {
-                fn encode_body(&self, buffer: &mut [u8]) -> Result<(), jacquard_common::xrpc::EncodeError>
+                fn encode_body(&self, buffer: &mut Vec<u8>) -> Result<(), jacquard_common::xrpc::EncodeError>
                 where
                     Self: #ser_path,
                 {
diff --git a/crates/jacquard-lexicon/src/derive_impl/xrpc_request.rs b/crates/jacquard-lexicon/src/derive_impl/xrpc_request.rs
index 40a781dd..76f2618e 100644
--- a/crates/jacquard-lexicon/src/derive_impl/xrpc_request.rs
+++ b/crates/jacquard-lexicon/src/derive_impl/xrpc_request.rs
@@ -24,17 +24,31 @@ fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<TokenStream> {
     let name = &input.ident;
     let generics = &input.generics;
 
-    // Detect if type has lifetime parameter
+    // Detect if type has any generic parameters (type params or lifetimes).
+    // BOS-style types use a type parameter `S: BosStr`; legacy types may use a lifetime.
+    // Either way, the XrpcRequest impl is for `#name` with no explicit args (Rust infers them),
+    // and the XrpcEndpoint uses `#name<S>` to thread the backing-string type through.
+    let has_type_params = generics.type_params().next().is_some();
     let has_lifetime = generics.lifetimes().next().is_some();
-    let lifetime = if has_lifetime {
-        quote! { <'_> }
+    let has_generics = has_type_params || has_lifetime;
+
+    // For XrpcRequest impl: use the struct's own generics clause unchanged.
+    // For XrpcEndpoint's Request<S> GAT: supply `S` as the single type argument if the
+    // request type is generic; otherwise supply nothing.
+    let request_in_endpoint = if has_generics {
+        quote! { #name<S> }
     } else {
-        quote! {}
+        quote! { #name }
     };
 
+    // For XrpcRequest impl bounds: pass through the full generics.
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
     let nsid = &attrs.nsid;
     let method = method_expr(&attrs.method);
     let output_ty = &attrs.output;
+    // Error type is always owned (DeserializeOwned); the BOS migration removed the 'de lifetime
+    // from XrpcResp::Err.  We accept whatever type the user named and use it without a param.
     let error_ty = attrs
         .error
         .as_ref()
@@ -52,11 +66,11 @@ fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<TokenStream> {
         impl ::jacquard_common::xrpc::XrpcResp for #response_name {
             const NSID: &'static str = #nsid;
             const ENCODING: &'static str = "application/json";
-            type Output<'de> = #output_ty<'de>;
-            type Err<'de> = #error_ty<'de>;
+            type Output<S: ::jacquard_common::BosStr> = #output_ty<S>;
+            type Err = #error_ty;
         }
 
-        impl #generics ::jacquard_common::xrpc::XrpcRequest for #name #lifetime {
+        impl #impl_generics ::jacquard_common::xrpc::XrpcRequest for #name #ty_generics #where_clause {
             const NSID: &'static str = #nsid;
             const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
             type Response = #response_name;
@@ -68,13 +82,6 @@ fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<TokenStream> {
         let endpoint_name = format_ident!("{}Endpoint", name);
         let path = format!("/xrpc/{}", nsid);
 
-        // Request type with or without lifetime
-        let request_type = if has_lifetime {
-            quote! { #name<'de> }
-        } else {
-            quote! { #name }
-        };
-
         output.extend(quote! {
             /// Endpoint marker for #name (server-side)
             pub struct #endpoint_name;
@@ -82,7 +89,7 @@ fn xrpc_request_impl(input: &DeriveInput) -> syn::Result<TokenStream> {
             impl ::jacquard_common::xrpc::XrpcEndpoint for #endpoint_name {
                 const PATH: &'static str = #path;
                 const METHOD: ::jacquard_common::xrpc::XrpcMethod = #method;
-                type Request<'de> = #request_type;
+                type Request<S: ::jacquard_common::BosStr> = #request_in_endpoint;
                 type Response = #response_name;
             }
         });
diff --git a/crates/jacquard/tests/agent.rs b/crates/jacquard/tests/agent.rs
index a5a277bd..f23e43ce 100644
--- a/crates/jacquard/tests/agent.rs
+++ b/crates/jacquard/tests/agent.rs
@@ -2,6 +2,7 @@ use std::collections::VecDeque;
 use std::sync::Arc;
 
 use http::{HeaderValue, Response as HttpResponse, StatusCode};
+use jacquard::BosStr;
 use jacquard::client::credential_session::{CredentialSession, SessionKey};
 use jacquard::client::{Agent, AtpSession};
 use jacquard::identity::resolver::{DidDocResponse, IdentityResolver, ResolverOptions};
@@ -46,15 +47,15 @@ impl IdentityResolver for MockClient {
         static OPTS: LazyLock<ResolverOptions> = LazyLock::new(ResolverOptions::default);
         &OPTS
     }
-    async fn resolve_handle(
+    async fn resolve_handle<S: BosStr + Sync>(
         &self,
-        _handle: &Handle<'_>,
-    ) -> std::result::Result<Did<'static>, jacquard::identity::resolver::IdentityError> {
+        _handle: &Handle<S>,
+    ) -> std::result::Result<Did, jacquard::identity::resolver::IdentityError> {
         Ok(Did::new_static("did:plc:alice").unwrap())
     }
-    async fn resolve_did_doc(
+    async fn resolve_did_doc<S: BosStr + Sync>(
         &self,
-        _did: &Did<'_>,
+        _did: &Did<S>,
     ) -> std::result::Result<DidDocResponse, jacquard::identity::resolver::IdentityError> {
         let doc = serde_json::json!({
             "id": "did:plc:alice",
@@ -126,7 +127,7 @@ async fn agent_delegates_to_session_and_refreshes() {
 
     let token = agent.refresh().await.expect("refresh ok");
     match token {
-        jacquard::AuthorizationToken::Bearer(s) => assert_eq!(s.as_ref(), "acc2"),
+        jacquard::AuthorizationToken::Bearer(s) => assert_eq!(s.as_str(), "acc2"),
         _ => panic!("expected Bearer token"),
     }
 
diff --git a/crates/jacquard/tests/credential_session.rs b/crates/jacquard/tests/credential_session.rs
index 5470a265..d944a550 100644
--- a/crates/jacquard/tests/credential_session.rs
+++ b/crates/jacquard/tests/credential_session.rs
@@ -3,6 +3,7 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 use http::{HeaderValue, Method, Response as HttpResponse, StatusCode};
+use jacquard::BosStr;
 use jacquard::client::AtpSession;
 use jacquard::client::credential_session::{CredentialSession, SessionKey};
 use jacquard::identity::resolver::{DidDocResponse, IdentityResolver, ResolverOptions};
@@ -11,6 +12,7 @@ use jacquard::types::string::Handle;
 use jacquard::xrpc::XrpcClient;
 use jacquard_common::http_client::HttpClient;
 use jacquard_common::session::{MemorySessionStore, SessionStore};
+use smol_str::SmolStr;
 use tokio::sync::{Mutex, RwLock};
 
 #[derive(Clone, Default)]
@@ -60,18 +62,18 @@ impl IdentityResolver for MockClient {
         &OPTS
     }
 
-    async fn resolve_handle(
+    async fn resolve_handle<S: BosStr + Sync>(
         &self,
-        handle: &Handle<'_>,
-    ) -> std::result::Result<Did<'static>, jacquard::identity::resolver::IdentityError> {
+        handle: &Handle<S>,
+    ) -> std::result::Result<Did, jacquard::identity::resolver::IdentityError> {
         // Return a fixed DID for any handle
         assert!(handle.as_str().contains('.'));
         Ok(Did::new_static("did:plc:alice").unwrap())
     }
 
-    async fn resolve_did_doc(
+    async fn resolve_did_doc<S: BosStr + Sync>(
         &self,
-        did: &Did<'_>,
+        did: &Did<S>,
     ) -> std::result::Result<DidDocResponse, jacquard::identity::resolver::IdentityError> {
         // Track calls and return a minimal DID doc with a PDS endpoint
         *self.did_doc_calls.write().await += 1;
@@ -193,7 +195,9 @@ async fn credential_login_and_auto_refresh() {
         .await
         .expect("xrpc send ok");
     assert_eq!(resp.status(), StatusCode::OK);
-    let out = resp
+    let out: jacquard::api::com_atproto::server::get_session::GetSessionOutput<
+        jacquard::CowStr<'_>,
+    > = resp
         .parse()
         .expect("parse ok after refresh (GetSession output)");
     assert_eq!(out.handle.as_str(), "alice.bsky.social");
@@ -250,9 +254,9 @@ async fn credential_login_and_auto_refresh() {
     // Verify store updated with refreshed tokens
     let key = SessionKey(
         Did::new_static("did:plc:alice").unwrap(),
-        jacquard::CowStr::from("session"),
+        SmolStr::from("session"),
     );
     let updated = store.get(&key).await.expect("session present");
-    assert_eq!(updated.access_jwt.as_ref(), "acc2");
-    assert_eq!(updated.refresh_jwt.as_ref(), "ref2");
+    assert_eq!(updated.access_jwt.as_str(), "acc2");
+    assert_eq!(updated.refresh_jwt.as_str(), "ref2");
 }
diff --git a/crates/jacquard/tests/oauth_auto_refresh.rs b/crates/jacquard/tests/oauth_auto_refresh.rs
index 0e1447b9..25c3c831 100644
--- a/crates/jacquard/tests/oauth_auto_refresh.rs
+++ b/crates/jacquard/tests/oauth_auto_refresh.rs
@@ -97,15 +97,14 @@ impl OAuthResolver for MockClient {
         md.pushed_authorization_request_endpoint = Some(SmolStr::from(format!("{}/par", issuer)));
         md.token_endpoint_auth_methods_supported = Some(vec![SmolStr::from("none")]);
         md.dpop_signing_alg_values_supported = Some(vec![SmolStr::from("ES256")]);
-        use jacquard::IntoStatic;
-        Ok(md.into_static())
+        Ok(md)
     }
 
     async fn get_resource_server_metadata(
         &self,
         _pds: &str,
     ) -> Result<OAuthAuthorizationServerMetadata, jacquard_oauth::resolver::ResolverError> {
-        // Return metadata pointing to the same issuer as above
+        // Return metadata pointing to the same issuer as above.
         let mut md = OAuthAuthorizationServerMetadata::default();
         md.issuer = SmolStr::from("https://issuer");
         md.token_endpoint = SmolStr::from("https://issuer/token");
@@ -114,10 +113,10 @@ impl OAuthResolver for MockClient {
         md.pushed_authorization_request_endpoint = Some(SmolStr::from("https://issuer/par"));
         md.token_endpoint_auth_methods_supported = Some(vec![SmolStr::from("none")]);
         md.dpop_signing_alg_values_supported = Some(vec![SmolStr::from("ES256")]);
-        Ok(md.into_static())
+        Ok(md)
     }
 
-    async fn verify_issuer<S: BosStr>(
+    async fn verify_issuer<S: BosStr + Sync>(
         &self,
         _server_metadata: &OAuthAuthorizationServerMetadata,
         _sub: &Did<S>,
diff --git a/crates/jacquard/tests/oauth_flow.rs b/crates/jacquard/tests/oauth_flow.rs
index 21660101..0d236545 100644
--- a/crates/jacquard/tests/oauth_flow.rs
+++ b/crates/jacquard/tests/oauth_flow.rs
@@ -3,11 +3,9 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 use http::{Response as HttpResponse, StatusCode};
+use jacquard::BosStr;
 use jacquard::client::Agent;
 use jacquard::xrpc::XrpcClient;
-use jacquard::BosStr;
-use jacquard::IntoStatic;
-use smol_str::SmolStr;
 use jacquard_common::http_client::HttpClient;
 use jacquard_oauth::atproto::AtprotoClientMetadata;
 use jacquard_oauth::authstore::ClientAuthStore;
@@ -15,6 +13,7 @@ use jacquard_oauth::client::OAuthClient;
 use jacquard_oauth::resolver::OAuthResolver;
 use jacquard_oauth::scopes::Scope;
 use jacquard_oauth::session::ClientData;
+use smol_str::SmolStr;
 
 #[derive(Clone, Default)]
 struct MockClient {
@@ -50,10 +49,8 @@ impl jacquard::identity::resolver::IdentityResolver for MockClient {
     async fn resolve_handle<S: BosStr + Sync>(
         &self,
         _handle: &jacquard::types::string::Handle<S>,
-    ) -> std::result::Result<
-        jacquard::types::did::Did,
-        jacquard::identity::resolver::IdentityError,
-    > {
+    ) -> std::result::Result<jacquard::types::did::Did, jacquard::identity::resolver::IdentityError>
+    {
         Ok(jacquard::types::did::Did::new_static("did:plc:alice").unwrap())
     }
     async fn resolve_did_doc<S: BosStr + Sync>(
@@ -85,20 +82,19 @@ impl OAuthResolver for MockClient {
         _input: &str,
     ) -> Result<
         (
-            jacquard_oauth::types::OAuthAuthorizationServerMetadata<'static>,
-            Option<jacquard_common::types::did_doc::DidDocument<'static>>,
+            jacquard_oauth::types::OAuthAuthorizationServerMetadata,
+            Option<jacquard_common::types::did_doc::DidDocument>,
         ),
         jacquard_oauth::resolver::ResolverError,
     > {
         let mut md = jacquard_oauth::types::OAuthAuthorizationServerMetadata::default();
-        md.issuer = jacquard::CowStr::from("https://issuer");
-        md.authorization_endpoint = jacquard::CowStr::from("https://issuer/authorize");
-        md.token_endpoint = jacquard::CowStr::from("https://issuer/token");
+        md.issuer = SmolStr::from("https://issuer");
+        md.authorization_endpoint = SmolStr::from("https://issuer/authorize");
+        md.token_endpoint = SmolStr::from("https://issuer/token");
         md.require_pushed_authorization_requests = Some(true);
-        md.pushed_authorization_request_endpoint =
-            Some(jacquard::CowStr::from("https://issuer/par"));
-        md.token_endpoint_auth_methods_supported = Some(vec![jacquard::CowStr::from("none")]);
-        md.dpop_signing_alg_values_supported = Some(vec![jacquard::CowStr::from("ES256")]);
+        md.pushed_authorization_request_endpoint = Some(SmolStr::from("https://issuer/par"));
+        md.token_endpoint_auth_methods_supported = Some(vec![SmolStr::from("none")]);
+        md.dpop_signing_alg_values_supported = Some(vec![SmolStr::from("ES256")]);
 
         // Simple DID doc pointing to https://pds
         let doc = serde_json::json!({
@@ -110,47 +106,45 @@ impl OAuthResolver for MockClient {
             }]
         });
         let buf = Bytes::from(serde_json::to_vec(&doc).unwrap());
-        let did_doc_b: jacquard_common::types::did_doc::DidDocument<'_> =
+        let did_doc: jacquard_common::types::did_doc::DidDocument =
             serde_json::from_slice(&buf).unwrap();
-        let did_doc = did_doc_b.into_static();
-        Ok((md.into_static(), Some(did_doc)))
+        Ok((md, Some(did_doc)))
     }
+
     async fn get_authorization_server_metadata(
         &self,
-        issuer: &CowStr<'_>,
+        issuer: &str,
     ) -> Result<
-        jacquard_oauth::types::OAuthAuthorizationServerMetadata<'static>,
+        jacquard_oauth::types::OAuthAuthorizationServerMetadata,
         jacquard_oauth::resolver::ResolverError,
     > {
         let mut md = jacquard_oauth::types::OAuthAuthorizationServerMetadata::default();
-        md.issuer = jacquard::CowStr::from(issuer.as_str());
-        md.authorization_endpoint = jacquard::CowStr::from(format!("{}/authorize", issuer));
-        md.token_endpoint = jacquard::CowStr::from(format!("{}/token", issuer));
+        md.issuer = SmolStr::from(issuer);
+        md.authorization_endpoint = SmolStr::from(format!("{}/authorize", issuer));
+        md.token_endpoint = SmolStr::from(format!("{}/token", issuer));
         md.require_pushed_authorization_requests = Some(true);
-        md.pushed_authorization_request_endpoint =
-            Some(jacquard::CowStr::from(format!("{}/par", issuer)));
-        md.token_endpoint_auth_methods_supported = Some(vec![jacquard::CowStr::from("none")]);
-        md.dpop_signing_alg_values_supported = Some(vec![jacquard::CowStr::from("ES256")]);
-        Ok(md.into_static())
+        md.pushed_authorization_request_endpoint = Some(SmolStr::from(format!("{}/par", issuer)));
+        md.token_endpoint_auth_methods_supported = Some(vec![SmolStr::from("none")]);
+        md.dpop_signing_alg_values_supported = Some(vec![SmolStr::from("ES256")]);
+        Ok(md)
     }
 
     async fn get_resource_server_metadata(
         &self,
-        _pds: &CowStr<'_>,
+        _pds: &str,
     ) -> Result<
-        jacquard_oauth::types::OAuthAuthorizationServerMetadata<'static>,
+        jacquard_oauth::types::OAuthAuthorizationServerMetadata,
         jacquard_oauth::resolver::ResolverError,
     > {
         let mut md = jacquard_oauth::types::OAuthAuthorizationServerMetadata::default();
-        md.issuer = jacquard::CowStr::from("https://issuer");
-        md.authorization_endpoint = jacquard::CowStr::from("https://issuer/authorize");
-        md.token_endpoint = jacquard::CowStr::from("https://issuer/token");
+        md.issuer = SmolStr::from("https://issuer");
+        md.authorization_endpoint = SmolStr::from("https://issuer/authorize");
+        md.token_endpoint = SmolStr::from("https://issuer/token");
         md.require_pushed_authorization_requests = Some(true);
-        md.pushed_authorization_request_endpoint =
-            Some(jacquard::CowStr::from("https://issuer/par"));
-        md.token_endpoint_auth_methods_supported = Some(vec![jacquard::CowStr::from("none")]);
-        md.dpop_signing_alg_values_supported = Some(vec![jacquard::CowStr::from("ES256")]);
-        Ok(md.into_static())
+        md.pushed_authorization_request_endpoint = Some(SmolStr::from("https://issuer/par"));
+        md.token_endpoint_auth_methods_supported = Some(vec![SmolStr::from("none")]);
+        md.dpop_signing_alg_values_supported = Some(vec![SmolStr::from("ES256")]);
+        Ok(md)
     }
 }
 
@@ -228,33 +222,32 @@ async fn oauth_end_to_end_mock_flow() {
 
     // Build metadata and call PAR to get an AuthRequestData, then save in store
     let (server_metadata, identity) = client.resolve_oauth("alice.bsky.social").await.unwrap();
-    let metadata = jacquard_oauth::request::OAuthMetadata {
+    let mut metadata = jacquard_oauth::request::OAuthMetadata {
         server_metadata,
         client_metadata: jacquard_oauth::atproto::atproto_client_metadata(
-            AtprotoClientMetadata::new_localhost(None, Some(vec![Scope::Atproto])),
+            &AtprotoClientMetadata::new_localhost(None, Some(vec![Scope::Atproto])),
             &None,
         )
-        .unwrap()
-        .into_static(),
+        .unwrap(),
         keyset: None,
     };
-    let login_hint = identity.map(|_| jacquard::CowStr::from("alice.bsky.social"));
+    let login_hint = identity.map(|_| SmolStr::from("alice.bsky.social"));
     let auth_req =
         jacquard_oauth::request::par(client.as_ref(), login_hint, None, &mut metadata, None)
             .await
             .unwrap();
     // Construct authorization URL as OAuthClient::start_auth would do
     #[derive(serde::Serialize)]
-    struct Parameters<'s> {
-        client_id: CowStr<'s>,
-        request_uri: jacquard::CowStr<'s>,
+    struct Parameters {
+        client_id: SmolStr,
+        request_uri: SmolStr,
     }
     let auth_url = format!(
         "{}?{}",
         metadata.server_metadata.authorization_endpoint,
         serde_html_form::to_string(Parameters {
             client_id: metadata.client_metadata.client_id.clone(),
-            request_uri: jacquard::CowStr::Owned(auth_req.request_uri.clone()),
+            request_uri: auth_req.request_uri.clone(),
         })
         .unwrap()
     );
diff --git a/crates/jacquard/tests/restore_pds_cache.rs b/crates/jacquard/tests/restore_pds_cache.rs
index 4967f45a..aa282eae 100644
--- a/crates/jacquard/tests/restore_pds_cache.rs
+++ b/crates/jacquard/tests/restore_pds_cache.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use bytes::Bytes;
 use http::{Response as HttpResponse, StatusCode};
+use jacquard::BosStr;
 use jacquard::client::credential_session::{CredentialSession, SessionKey};
 use jacquard::client::{AtpSession, FileAuthStore};
 use jacquard::identity::resolver::{DidDocResponse, IdentityResolver, ResolverOptions};
@@ -44,15 +45,15 @@ impl IdentityResolver for MockResolver {
         static OPTS: LazyLock<ResolverOptions> = LazyLock::new(ResolverOptions::default);
         &OPTS
     }
-    async fn resolve_handle(
+    async fn resolve_handle<S: BosStr + Sync>(
         &self,
-        _handle: &Handle<'_>,
-    ) -> std::result::Result<Did<'static>, jacquard::identity::resolver::IdentityError> {
+        _handle: &Handle<S>,
+    ) -> std::result::Result<Did, jacquard::identity::resolver::IdentityError> {
         Ok(Did::new_static("did:plc:alice").unwrap())
     }
-    async fn resolve_did_doc(
+    async fn resolve_did_doc<S: BosStr + Sync>(
         &self,
-        _did: &Did<'_>,
+        _did: &Did<S>,
     ) -> std::result::Result<DidDocResponse, jacquard::identity::resolver::IdentityError> {
         *self.did_doc_calls.write().await += 1;
         let doc = serde_json::json!({
diff --git a/crates/jacquard/tests/xrpc_derive.rs b/crates/jacquard/tests/xrpc_derive.rs
index f3b5e9e0..b4ae211e 100644
--- a/crates/jacquard/tests/xrpc_derive.rs
+++ b/crates/jacquard/tests/xrpc_derive.rs
@@ -1,27 +1,28 @@
-use jacquard::{CowStr, IntoStatic};
+use jacquard::{BosStr, DefaultStr, IntoStatic};
 use jacquard_derive::XrpcRequest;
 use serde::{Deserialize, Serialize};
+use smol_str::SmolStr;
 
-// Test output type
+// Test output type — uses BOS type parameter so it can borrow from the response buffer or own
+// the data via the default `DefaultStr = SmolStr` backend.
 #[derive(Serialize, Deserialize, IntoStatic)]
-pub struct GetThingOutput<'a> {
-    #[serde(borrow)]
-    pub result: CowStr<'a>,
+#[serde(bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+pub struct GetThingOutput<S: BosStr = DefaultStr> {
+    pub result: S,
 }
 
 // Test basic query endpoint
 #[derive(Serialize, Deserialize, XrpcRequest)]
 #[xrpc(nsid = "com.example.getThing", method = Query, output = GetThingOutput)]
-pub struct GetThing<'a> {
-    #[serde(borrow)]
-    pub id: CowStr<'a>,
+pub struct GetThing<S: BosStr = DefaultStr> {
+    pub id: S,
 }
 
 // Test procedure endpoint
 #[derive(Serialize, Deserialize, IntoStatic)]
-pub struct CreateThingOutput<'a> {
-    #[serde(borrow)]
-    pub id: CowStr<'a>,
+#[serde(bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+pub struct CreateThingOutput<S: BosStr = DefaultStr> {
+    pub id: S,
 }
 
 #[derive(Serialize, Deserialize, XrpcRequest)]
@@ -30,32 +31,29 @@ pub struct CreateThingOutput<'a> {
     method = Procedure,
     output = CreateThingOutput
 )]
-pub struct CreateThing<'a> {
-    #[serde(borrow)]
-    pub name: CowStr<'a>,
+pub struct CreateThing<S: BosStr = DefaultStr> {
+    pub name: S,
 }
 
-// Test with custom error type
+// Test with custom error type — errors must be DeserializeOwned (no borrowing), so they use SmolStr
+// directly rather than a BOS type parameter.
 #[derive(Serialize, Deserialize, Debug, thiserror::Error)]
-#[error("Custom error")]
-pub struct CustomError<'a> {
-    #[serde(borrow)]
-    pub message: CowStr<'a>,
+#[error("Custom error: {message}")]
+pub struct CustomError {
+    pub message: SmolStr,
 }
 
-impl jacquard::IntoStatic for CustomError<'_> {
-    type Output = CustomError<'static>;
+impl jacquard::IntoStatic for CustomError {
+    type Output = CustomError;
     fn into_static(self) -> Self::Output {
-        CustomError {
-            message: self.message.into_static(),
-        }
+        self
     }
 }
 
 #[derive(Serialize, Deserialize, IntoStatic)]
-pub struct DoThingOutput<'a> {
-    #[serde(borrow)]
-    pub status: CowStr<'a>,
+#[serde(bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+pub struct DoThingOutput<S: BosStr = DefaultStr> {
+    pub status: S,
 }
 
 #[derive(Serialize, Deserialize, XrpcRequest)]
@@ -65,16 +63,15 @@ pub struct DoThingOutput<'a> {
     output = DoThingOutput,
     error = CustomError
 )]
-pub struct DoThing<'a> {
-    #[serde(borrow)]
-    pub param: CowStr<'a>,
+pub struct DoThing<S: BosStr = DefaultStr> {
+    pub param: S,
 }
 
 // Test server-side endpoint generation
 #[derive(Serialize, Deserialize, IntoStatic)]
-pub struct ServerThingOutput<'a> {
-    #[serde(borrow)]
-    pub status: CowStr<'a>,
+#[serde(bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+pub struct ServerThingOutput<S: BosStr = DefaultStr> {
+    pub status: S,
 }
 
 #[derive(Serialize, Deserialize, IntoStatic, XrpcRequest)]
@@ -84,9 +81,9 @@ pub struct ServerThingOutput<'a> {
     output = ServerThingOutput,
     server
 )]
-pub struct ServerThing<'a> {
-    #[serde(borrow)]
-    pub query: CowStr<'a>,
+#[serde(bound(deserialize = "S: Deserialize<'de> + BosStr"))]
+pub struct ServerThing<S: BosStr = DefaultStr> {
+    pub query: S,
 }
 
 #[test]
@@ -103,13 +100,13 @@ fn test_xrpc_request_impl() {
     use jacquard::xrpc::{XrpcMethod, XrpcRequest};
 
     // Query endpoint
-    assert_eq!(GetThing::NSID, "com.example.getThing");
-    assert!(matches!(GetThing::METHOD, XrpcMethod::Query));
+    assert_eq!(GetThing::<&str>::NSID, "com.example.getThing");
+    assert!(matches!(GetThing::<&str>::METHOD, XrpcMethod::Query));
 
     // Procedure endpoint
-    assert_eq!(CreateThing::NSID, "com.example.createThing");
+    assert_eq!(CreateThing::<&str>::NSID, "com.example.createThing");
     assert!(matches!(
-        CreateThing::METHOD,
+        CreateThing::<&str>::METHOD,
         XrpcMethod::Procedure("application/json")
     ));
 }
diff --git a/examples/app_password_create_post.rs b/examples/app_password_create_post.rs
index 2728cca1..6a33898f 100644
--- a/examples/app_password_create_post.rs
+++ b/examples/app_password_create_post.rs
@@ -3,6 +3,7 @@ use jacquard::CowStr;
 use jacquard::api::app_bsky::feed::post::Post;
 use jacquard::client::{Agent, AgentSessionExt, MemoryCredentialSession};
 use jacquard::types::string::Datetime;
+use smol_str::SmolStr;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "Create a simple post")]
diff --git a/examples/axum_server.rs b/examples/axum_server.rs
index 5da3cee7..2e5aea27 100644
--- a/examples/axum_server.rs
+++ b/examples/axum_server.rs
@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use axum::{Json, Router, extract::State, http::StatusCode, response::IntoResponse};
 use jacquard::{
+    CowStr,
     api::com_atproto::identity::resolve_did::{ResolveDidOutput, ResolveDidRequest},
     identity::{JacquardResolver, resolver::IdentityResolver},
     types::value::to_data,
@@ -13,8 +14,8 @@ use tracing_subscriber::EnvFilter;
 #[axum_macros::debug_handler]
 async fn resolve_did(
     State(state): State<Arc<AppState>>,
-    ExtractXrpc(args): ExtractXrpc<ResolveDidRequest>,
-) -> Result<Json<ResolveDidOutput<'static>>, XrpcErrorResponse> {
+    ExtractXrpc(args): ExtractXrpc<ResolveDidRequest, CowStr<'_>>,
+) -> Result<Json<ResolveDidOutput<CowStr<'static>>>, XrpcErrorResponse> {
     let doc = state
         .resolver
         .resolve_did_doc_owned(&args.did)
diff --git a/examples/create_whitewind_post.rs b/examples/create_whitewind_post.rs
index c873b76c..0fe63b73 100644
--- a/examples/create_whitewind_post.rs
+++ b/examples/create_whitewind_post.rs
@@ -62,7 +62,11 @@ async fn main() -> miette::Result<()> {
     let url_str = format!(
         "https://whtwnd.nat.vg/{}/{}",
         output.uri.authority(),
-        output.uri.rkey().map(|r| r.as_ref()).unwrap_or("")
+        output
+            .uri
+            .rkey()
+            .map(|r| r.to_string())
+            .unwrap_or("".to_string())
     );
     let url = Uri::parse(url_str.as_str()).into_diagnostic()?;
     println!("View at: {}", url);
diff --git a/examples/moderated_timeline.rs b/examples/moderated_timeline.rs
index 304a0a64..b16677dd 100644
--- a/examples/moderated_timeline.rs
+++ b/examples/moderated_timeline.rs
@@ -42,7 +42,7 @@ async fn main() -> miette::Result<()> {
     let args = Args::parse();
 
     // Extract labeler DIDs from the static JSON (used for testing)
-    let services: GetServicesOutput<'static> =
+    let services: GetServicesOutput =
         serde_json::from_str(LABELER_SERVICES_JSON).expect("failed to parse labeler services");
 
     let mut accepted_labelers = Vec::new();
diff --git a/examples/oauth_timeline.rs b/examples/oauth_timeline.rs
index ae21fa6b..c258e149 100644
--- a/examples/oauth_timeline.rs
+++ b/examples/oauth_timeline.rs
@@ -10,6 +10,7 @@ use jacquard::xrpc::XrpcClient;
 #[cfg(not(feature = "loopback"))]
 use jacquard_oauth::types::AuthorizeOptions;
 use miette::IntoDiagnostic;
+use smol_str::SmolStr;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "Jacquard - OAuth (DPoP) loopback demo")]
diff --git a/examples/post_with_image.rs b/examples/post_with_image.rs
index 7933201a..70b96b93 100644
--- a/examples/post_with_image.rs
+++ b/examples/post_with_image.rs
@@ -8,6 +8,7 @@ use jacquard::oauth::loopback::LoopbackConfig;
 use jacquard::types::blob::MimeType;
 use jacquard::types::string::Datetime;
 use miette::IntoDiagnostic;
+use smol_str::SmolStr;
 use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
@@ -55,18 +56,18 @@ async fn main() -> miette::Result<()> {
         Some("webp") => "image/webp",
         _ => "image/jpeg", // default
     };
-    let mime_type = MimeType::new_static(mime_str);
+    let mime_type = MimeType::new(mime_str);
 
     println!("Uploading image...");
     let blob = agent.upload_blob(image_data, mime_type).await?;
 
     // Create post with image embed
     let post = Post {
-        text: CowStr::from(args.text),
+        text: SmolStr::from(args.text),
         created_at: Datetime::now(),
         embed: Some(PostEmbed::Images(Box::new(Images {
             images: vec![Image {
-                alt: CowStr::from(args.alt.unwrap_or_default()),
+                alt: SmolStr::from(args.alt.unwrap_or_default()),
                 image: blob.into(),
                 aspect_ratio: None,
                 extra_data: Default::default(),
diff --git a/examples/public_atproto_feed.rs b/examples/public_atproto_feed.rs
index 85695ec1..9983778e 100644
--- a/examples/public_atproto_feed.rs
+++ b/examples/public_atproto_feed.rs
@@ -21,7 +21,7 @@ async fn main() -> miette::Result<()> {
 
     let request = GetFeed::new().feed(feed_uri).limit(10).build();
 
-    let response = http.xrpc(base).send(&request).await?;
+    let response = http.xrpc(&base.borrow()).send(&request).await?;
     let output = response.into_output()?;
 
     println!("Latest posts from the AT Protocol feed:\n");
diff --git a/examples/read_tangled_repo.rs b/examples/read_tangled_repo.rs
index 76711b7f..45509e9f 100644
--- a/examples/read_tangled_repo.rs
+++ b/examples/read_tangled_repo.rs
@@ -23,7 +23,7 @@ async fn main() -> miette::Result<()> {
     let agent = BasicClient::unauthenticated();
 
     // Use Agent's fetch_record helper with typed record URI
-    let output: Repo<'_> = agent.fetch_record(&uri).await?.into();
+    let output: Repo = agent.fetch_record(&uri).await?.into();
 
     println!("Tangled Repository\n");
     println!("URI: {}", uri);