sync

lexicons/atproto/atp_lexicon_atproto.ml

···
 module Com = struct
   module Atproto = struct
     module Repo = struct
+      module StrongRef = struct
+type main = {
+  cid : string;
+  uri : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ cid uri -> { cid; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.strongRef" ~enc:(fun _ -> "com.atproto.repo.strongRef")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+      end
       module Defs = struct
 type commit_meta = {
   cid : string;
···
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.defs#commitMeta" ~enc:(fun _ -> "com.atproto.repo.defs#commitMeta")
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "rev" Jsont.string ~enc:(fun r -> r.rev)
-  |> Jsont.Object.finish
-
-      end
-      module GetRecord = struct
-type params = {
-  cid : string option;
-  collection : string;
-  repo : string;
-  rkey : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cid collection repo rkey -> {
-      cid;
-      collection;
-      repo;
-      rkey;
-    })
-  |> Jsont.Object.opt_mem "cid" Jsont.string
-       ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "collection" Jsont.string
-       ~enc:(fun r -> r.collection)
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "rkey" Jsont.string
-       ~enc:(fun r -> r.rkey)
-  |> Jsont.Object.finish
-
-type output = {
-  cid : string option;
-  uri : string;
-  value : Jsont.json;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cid uri value -> { cid; uri; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.getRecord#output" ~enc:(fun _ -> "com.atproto.repo.getRecord#output")
-  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module StrongRef = struct
-type main = {
-  cid : string;
+      module GetRecord = struct
+type params = {
+  cid : string option;
+  collection : string;
+  repo : string;
+  rkey : string;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cid collection repo rkey -> {
+      cid;
+      collection;
+      repo;
+      rkey;
+    })
+  |> Jsont.Object.opt_mem "cid" Jsont.string
+       ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "collection" Jsont.string
+       ~enc:(fun r -> r.collection)
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "rkey" Jsont.string
+       ~enc:(fun r -> r.rkey)
+  |> Jsont.Object.finish
+
+type output = {
+  cid : string option;
   uri : string;
+  value : Jsont.json;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ cid uri -> { cid; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.strongRef" ~enc:(fun _ -> "com.atproto.repo.strongRef")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cid uri value -> { cid; uri; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.getRecord#output" ~enc:(fun _ -> "com.atproto.repo.getRecord#output")
+  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module CreateRecord = struct
+      module DeleteRecord = struct
 type input = {
   collection : string;
-  record : Jsont.json;
   repo : string;
-  rkey : string option;
+  rkey : string;
   swap_commit : string option;
-  validate : bool option;
+  swap_record : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ collection record repo rkey swap_commit validate -> { collection; record; repo; rkey; swap_commit; validate })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.createRecord#input" ~enc:(fun _ -> "com.atproto.repo.createRecord#input")
+    (fun _typ collection repo rkey swap_commit swap_record -> { collection; repo; rkey; swap_commit; swap_record })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.deleteRecord#input" ~enc:(fun _ -> "com.atproto.repo.deleteRecord#input")
   |> Jsont.Object.mem "collection" Jsont.string ~enc:(fun r -> r.collection)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.opt_mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
+  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
   |> Jsont.Object.opt_mem "swapCommit" Jsont.string ~enc:(fun r -> r.swap_commit)
-  |> Jsont.Object.opt_mem "validate" Jsont.bool ~enc:(fun r -> r.validate)
+  |> Jsont.Object.opt_mem "swapRecord" Jsont.string ~enc:(fun r -> r.swap_record)
   |> Jsont.Object.finish
 
 type output = {
-  cid : string;
   commit : Defs.commit_meta option;
-  uri : string;
-  validation_status : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cid commit uri validation_status -> { cid; commit; uri; validation_status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.createRecord#output" ~enc:(fun _ -> "com.atproto.repo.createRecord#output")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+    (fun _typ commit -> { commit })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.deleteRecord#output" ~enc:(fun _ -> "com.atproto.repo.deleteRecord#output")
   |> Jsont.Object.opt_mem "commit" Defs.commit_meta_jsont ~enc:(fun r -> r.commit)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "validationStatus" Jsont.string ~enc:(fun r -> r.validation_status)
   |> Jsont.Object.finish
 
       end
-      module DeleteRecord = struct
+      module CreateRecord = struct
 type input = {
   collection : string;
+  record : Jsont.json;
   repo : string;
-  rkey : string;
+  rkey : string option;
   swap_commit : string option;
-  swap_record : string option;
+  validate : bool option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ collection repo rkey swap_commit swap_record -> { collection; repo; rkey; swap_commit; swap_record })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.deleteRecord#input" ~enc:(fun _ -> "com.atproto.repo.deleteRecord#input")
+    (fun _typ collection record repo rkey swap_commit validate -> { collection; record; repo; rkey; swap_commit; validate })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.createRecord#input" ~enc:(fun _ -> "com.atproto.repo.createRecord#input")
   |> Jsont.Object.mem "collection" Jsont.string ~enc:(fun r -> r.collection)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
+  |> Jsont.Object.opt_mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
   |> Jsont.Object.opt_mem "swapCommit" Jsont.string ~enc:(fun r -> r.swap_commit)
-  |> Jsont.Object.opt_mem "swapRecord" Jsont.string ~enc:(fun r -> r.swap_record)
+  |> Jsont.Object.opt_mem "validate" Jsont.bool ~enc:(fun r -> r.validate)
   |> Jsont.Object.finish
 
 type output = {
+  cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
+  validation_status : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ commit -> { commit })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.deleteRecord#output" ~enc:(fun _ -> "com.atproto.repo.deleteRecord#output")
+    (fun _typ cid commit uri validation_status -> { cid; commit; uri; validation_status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.createRecord#output" ~enc:(fun _ -> "com.atproto.repo.createRecord#output")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.opt_mem "commit" Defs.commit_meta_jsont ~enc:(fun r -> r.commit)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.opt_mem "validationStatus" Jsont.string ~enc:(fun r -> r.validation_status)
   |> Jsont.Object.finish
 
       end

lexicons/atproto/atp_lexicon_atproto.mli

···
 module Com : sig
   module Atproto : sig
     module Repo : sig
-      module Defs : sig
+      module StrongRef : sig
 
-type commit_meta = {
+type main = {
   cid : string;
-  rev : string;
+  uri : string;
 }
 
-(** Jsont codec for {!type:commit_meta}. *)
-val commit_meta_jsont : commit_meta Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
-      module GetRecord : sig
-(** Get a single record from a repository. Does not require auth. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  cid : string option;  (** The CID of the version of the record. If not specified, then return the most recent version. *)
-  collection : string;  (** The NSID of the record collection. *)
-  repo : string;  (** The handle or DID of the repo. *)
-  rkey : string;  (** The Record Key. *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
+      module Defs : sig
 
-type output = {
-  cid : string option;
-  uri : string;
-  value : Jsont.json;
+type commit_meta = {
+  cid : string;
+  rev : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:commit_meta}. *)
+val commit_meta_jsont : commit_meta Jsont.t
 
       end
       module ListRecords : sig
···
 val output_jsont : output Jsont.t
 
       end
-      module StrongRef : sig
+      module GetRecord : sig
+(** Get a single record from a repository. Does not require auth. *)
 
-type main = {
-  cid : string;
+(** Query/procedure parameters. *)
+type params = {
+  cid : string option;  (** The CID of the version of the record. If not specified, then return the most recent version. *)
+  collection : string;  (** The NSID of the record collection. *)
+  repo : string;  (** The handle or DID of the repo. *)
+  rkey : string;  (** The Record Key. *)
+}
+
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
+
+
+type output = {
+  cid : string option;
   uri : string;
+  value : Jsont.json;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
       module PutRecord : sig
···
 val output_jsont : output Jsont.t
 
       end
-      module CreateRecord : sig
-(** Create a single new repository record. Requires auth, implemented by PDS. *)
+      module DeleteRecord : sig
+(** Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS. *)
 
 
 type input = {
   collection : string;  (** The NSID of the record collection. *)
-  record : Jsont.json;  (** The record itself. Must contain a $type field. *)
   repo : string;  (** The handle or DID of the repo (aka, current account). *)
-  rkey : string option;  (** The Record Key. *)
+  rkey : string;  (** The Record Key. *)
   swap_commit : string option;  (** Compare and swap with the previous commit by CID. *)
-  validate : bool option;  (** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. *)
+  swap_record : string option;  (** Compare and swap with the previous record by CID. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
-  cid : string;
   commit : Defs.commit_meta option;
-  uri : string;
-  validation_status : string option;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module DeleteRecord : sig
-(** Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS. *)
+      module CreateRecord : sig
+(** Create a single new repository record. Requires auth, implemented by PDS. *)
 
 
 type input = {
   collection : string;  (** The NSID of the record collection. *)
+  record : Jsont.json;  (** The record itself. Must contain a $type field. *)
   repo : string;  (** The handle or DID of the repo (aka, current account). *)
-  rkey : string;  (** The Record Key. *)
+  rkey : string option;  (** The Record Key. *)
   swap_commit : string option;  (** Compare and swap with the previous commit by CID. *)
-  swap_record : string option;  (** Compare and swap with the previous record by CID. *)
+  validate : bool option;  (** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
+  cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
+  validation_status : string option;
 }
 
 (** Jsont codec for {!type:output}. *)

lexicons/bsky/atp_lexicon_bsky.ml

···
 
 module Com = struct
   module Atproto = struct
-    module Moderation = struct
-      module Defs = struct
-type subject_type = string
-let subject_type_jsont = Jsont.string
-
-type reason_violation = string
-let reason_violation_jsont = Jsont.string
-
-type reason_type = string
-let reason_type_jsont = Jsont.string
-
-type reason_spam = string
-let reason_spam_jsont = Jsont.string
-
-type reason_sexual = string
-let reason_sexual_jsont = Jsont.string
-
-type reason_rude = string
-let reason_rude_jsont = Jsont.string
-
-type reason_other = string
-let reason_other_jsont = Jsont.string
-
-type reason_misleading = string
-let reason_misleading_jsont = Jsont.string
-
-type reason_appeal = string
-let reason_appeal_jsont = Jsont.string
-
-      end
-    end
     module Label = struct
       module Defs = struct
 type self_label = {
···
 
       end
     end
+    module Moderation = struct
+      module Defs = struct
+type subject_type = string
+let subject_type_jsont = Jsont.string
+
+type reason_violation = string
+let reason_violation_jsont = Jsont.string
+
+type reason_type = string
+let reason_type_jsont = Jsont.string
+
+type reason_spam = string
+let reason_spam_jsont = Jsont.string
+
+type reason_sexual = string
+let reason_sexual_jsont = Jsont.string
+
+type reason_rude = string
+let reason_rude_jsont = Jsont.string
+
+type reason_other = string
+let reason_other_jsont = Jsont.string
+
+type reason_misleading = string
+let reason_misleading_jsont = Jsont.string
+
+type reason_appeal = string
+let reason_appeal_jsont = Jsont.string
+
+      end
+    end
   end
 end
 module App = struct
   module Bsky = struct
-    module AuthFullApp = struct
+    module AuthManageLabelerService = struct
 type main = unit
 let main_jsont = Jsont.ignore
 
···
 let main_jsont = Jsont.ignore
 
     end
+    module AuthManageModeration = struct
+type main = unit
+let main_jsont = Jsont.ignore
+
+    end
+    module Richtext = struct
+      module Facet = struct
+type tag = {
+  tag : string;
+}
+
+let tag_jsont =
+  Jsont.Object.map ~kind:"Tag"
+    (fun _typ tag -> { tag })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#tag" ~enc:(fun _ -> "app.bsky.richtext.facet#tag")
+  |> Jsont.Object.mem "tag" Jsont.string ~enc:(fun r -> r.tag)
+  |> Jsont.Object.finish
+
+type mention = {
+  did : string;
+}
+
+let mention_jsont =
+  Jsont.Object.map ~kind:"Mention"
+    (fun _typ did -> { did })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#mention" ~enc:(fun _ -> "app.bsky.richtext.facet#mention")
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.finish
+
+type link = {
+  uri : string;
+}
+
+let link_jsont =
+  Jsont.Object.map ~kind:"Link"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#link" ~enc:(fun _ -> "app.bsky.richtext.facet#link")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type byte_slice = {
+  byte_end : int;
+  byte_start : int;
+}
+
+let byte_slice_jsont =
+  Jsont.Object.map ~kind:"Byte_slice"
+    (fun _typ byte_end byte_start -> { byte_end; byte_start })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#byteSlice" ~enc:(fun _ -> "app.bsky.richtext.facet#byteSlice")
+  |> Jsont.Object.mem "byteEnd" Jsont.int ~enc:(fun r -> r.byte_end)
+  |> Jsont.Object.mem "byteStart" Jsont.int ~enc:(fun r -> r.byte_start)
+  |> Jsont.Object.finish
+
+type main = {
+  features : Jsont.json list;
+  index : byte_slice;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ features index -> { features; index })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet" ~enc:(fun _ -> "app.bsky.richtext.facet")
+  |> Jsont.Object.mem "features" (Jsont.list Jsont.json) ~enc:(fun r -> r.features)
+  |> Jsont.Object.mem "index" byte_slice_jsont ~enc:(fun r -> r.index)
+  |> Jsont.Object.finish
+
+      end
+    end
     module AuthManageFeedDeclarations = struct
 type main = unit
 let main_jsont = Jsont.ignore
 
     end
-    module AuthManageNotifications = struct
+    module AuthFullApp = struct
 type main = unit
 let main_jsont = Jsont.ignore
 
     end
-    module AuthManageModeration = struct
+    module AuthManageNotifications = struct
 type main = unit
 let main_jsont = Jsont.ignore
 
···
 let main_jsont = Jsont.ignore
 
     end
-    module AuthManageLabelerService = struct
+    module Ageassurance = struct
+      module Defs = struct
+type status = string
+let status_jsont = Jsont.string
+
+type state_metadata = {
+  account_created_at : string option;
+}
+
+let state_metadata_jsont =
+  Jsont.Object.map ~kind:"State_metadata"
+    (fun _typ account_created_at -> { account_created_at })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#stateMetadata" ~enc:(fun _ -> "app.bsky.ageassurance.defs#stateMetadata")
+  |> Jsont.Object.opt_mem "accountCreatedAt" Jsont.string ~enc:(fun r -> r.account_created_at)
+  |> Jsont.Object.finish
+
+type event = {
+  access : string;
+  attempt_id : string;
+  complete_ip : string option;
+  complete_ua : string option;
+  country_code : string;
+  created_at : string;
+  email : string option;
+  init_ip : string option;
+  init_ua : string option;
+  region_code : string option;
+  status : string;
+}
+
+let event_jsont =
+  Jsont.Object.map ~kind:"Event"
+    (fun _typ access attempt_id complete_ip complete_ua country_code created_at email init_ip init_ua region_code status -> { access; attempt_id; complete_ip; complete_ua; country_code; created_at; email; init_ip; init_ua; region_code; status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#event" ~enc:(fun _ -> "app.bsky.ageassurance.defs#event")
+  |> Jsont.Object.mem "access" Jsont.string ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "attemptId" Jsont.string ~enc:(fun r -> r.attempt_id)
+  |> Jsont.Object.opt_mem "completeIp" Jsont.string ~enc:(fun r -> r.complete_ip)
+  |> Jsont.Object.opt_mem "completeUa" Jsont.string ~enc:(fun r -> r.complete_ua)
+  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "email" Jsont.string ~enc:(fun r -> r.email)
+  |> Jsont.Object.opt_mem "initIp" Jsont.string ~enc:(fun r -> r.init_ip)
+  |> Jsont.Object.opt_mem "initUa" Jsont.string ~enc:(fun r -> r.init_ua)
+  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
+  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.finish
+
+type config_region = {
+  country_code : string;
+  min_access_age : int;
+  region_code : string option;
+  rules : Jsont.json list;
+}
+
+let config_region_jsont =
+  Jsont.Object.map ~kind:"Config_region"
+    (fun _typ country_code min_access_age region_code rules -> { country_code; min_access_age; region_code; rules })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegion" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegion")
+  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
+  |> Jsont.Object.mem "minAccessAge" Jsont.int ~enc:(fun r -> r.min_access_age)
+  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
+  |> Jsont.Object.mem "rules" (Jsont.list Jsont.json) ~enc:(fun r -> r.rules)
+  |> Jsont.Object.finish
+
+type access = string
+let access_jsont = Jsont.string
+
+type state = {
+  access : access;
+  last_initiated_at : string option;
+  status : status;
+}
+
+let state_jsont =
+  Jsont.Object.map ~kind:"State"
+    (fun _typ access last_initiated_at status -> { access; last_initiated_at; status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#state" ~enc:(fun _ -> "app.bsky.ageassurance.defs#state")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.opt_mem "lastInitiatedAt" Jsont.string ~enc:(fun r -> r.last_initiated_at)
+  |> Jsont.Object.mem "status" status_jsont ~enc:(fun r -> r.status)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_declared_under_age = {
+  access : access;
+  age : int;
+}
+
+let config_region_rule_if_declared_under_age_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_declared_under_age"
+    (fun _typ access age -> { access; age })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_declared_over_age = {
+  access : access;
+  age : int;
+}
+
+let config_region_rule_if_declared_over_age_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_declared_over_age"
+    (fun _typ access age -> { access; age })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_assured_under_age = {
+  access : access;
+  age : int;
+}
+
+let config_region_rule_if_assured_under_age_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_assured_under_age"
+    (fun _typ access age -> { access; age })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_assured_over_age = {
+  access : access;
+  age : int;
+}
+
+let config_region_rule_if_assured_over_age_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_assured_over_age"
+    (fun _typ access age -> { access; age })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_account_older_than = {
+  access : access;
+  date : string;
+}
+
+let config_region_rule_if_account_older_than_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_account_older_than"
+    (fun _typ access date -> { access; date })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "date" Jsont.string ~enc:(fun r -> r.date)
+  |> Jsont.Object.finish
+
+type config_region_rule_if_account_newer_than = {
+  access : access;
+  date : string;
+}
+
+let config_region_rule_if_account_newer_than_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_if_account_newer_than"
+    (fun _typ access date -> { access; date })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.mem "date" Jsont.string ~enc:(fun r -> r.date)
+  |> Jsont.Object.finish
+
+type config_region_rule_default = {
+  access : access;
+}
+
+let config_region_rule_default_jsont =
+  Jsont.Object.map ~kind:"Config_region_rule_default"
+    (fun _typ access -> { access })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleDefault" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleDefault")
+  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+  |> Jsont.Object.finish
+
+type config = {
+  regions : config_region list;
+}
+
+let config_jsont =
+  Jsont.Object.map ~kind:"Config"
+    (fun _typ regions -> { regions })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#config" ~enc:(fun _ -> "app.bsky.ageassurance.defs#config")
+  |> Jsont.Object.mem "regions" (Jsont.list config_region_jsont) ~enc:(fun r -> r.regions)
+  |> Jsont.Object.finish
+
+      end
+      module Begin = struct
+type input = {
+  country_code : string;
+  email : string;
+  language : string;
+  region_code : string option;
+}
+
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ country_code email language region_code -> { country_code; email; language; region_code })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.begin#input" ~enc:(fun _ -> "app.bsky.ageassurance.begin#input")
+  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
+  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
+  |> Jsont.Object.mem "language" Jsont.string ~enc:(fun r -> r.language)
+  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
+  |> Jsont.Object.finish
+
+type output = Defs.state
+
+let output_jsont = Defs.state_jsont
+
+      end
+      module GetState = struct
+type params = {
+  country_code : string;
+  region_code : string option;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun country_code region_code -> {
+      country_code;
+      region_code;
+    })
+  |> Jsont.Object.mem "countryCode" Jsont.string
+       ~enc:(fun r -> r.country_code)
+  |> Jsont.Object.opt_mem "regionCode" Jsont.string
+       ~enc:(fun r -> r.region_code)
+  |> Jsont.Object.finish
+
+type output = {
+  metadata : Defs.state_metadata;
+  state : Defs.state;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ metadata state -> { metadata; state })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.getState#output" ~enc:(fun _ -> "app.bsky.ageassurance.getState#output")
+  |> Jsont.Object.mem "metadata" Defs.state_metadata_jsont ~enc:(fun r -> r.metadata)
+  |> Jsont.Object.mem "state" Defs.state_jsont ~enc:(fun r -> r.state)
+  |> Jsont.Object.finish
+
+      end
+      module GetConfig = struct
+type output = Defs.config
+
+let output_jsont = Defs.config_jsont
+
+      end
+    end
+    module Labeler = struct
+      module Defs = struct
+type labeler_viewer_state = {
+  like : string option;
+}
+
+let labeler_viewer_state_jsont =
+  Jsont.Object.map ~kind:"Labeler_viewer_state"
+    (fun _typ like -> { like })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerViewerState" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerViewerState")
+  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
+  |> Jsont.Object.finish
+
+type labeler_policies = {
+  label_value_definitions : Com.Atproto.Label.Defs.label_value_definition list option;
+  label_values : Com.Atproto.Label.Defs.label_value list;
+}
+
+let labeler_policies_jsont =
+  Jsont.Object.map ~kind:"Labeler_policies"
+    (fun _typ label_value_definitions label_values -> { label_value_definitions; label_values })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerPolicies" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerPolicies")
+  |> Jsont.Object.opt_mem "labelValueDefinitions" (Jsont.list Com.Atproto.Label.Defs.label_value_definition_jsont) ~enc:(fun r -> r.label_value_definitions)
+  |> Jsont.Object.mem "labelValues" (Jsont.list Com.Atproto.Label.Defs.label_value_jsont) ~enc:(fun r -> r.label_values)
+  |> Jsont.Object.finish
+
+type labeler_view_detailed = {
+  cid : string;
+  creator : Jsont.json;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  policies : Jsont.json;
+  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;
+  subject_collections : string list option;
+  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;
+  uri : string;
+  viewer : Jsont.json option;
+}
+
+let labeler_view_detailed_jsont =
+  Jsont.Object.map ~kind:"Labeler_view_detailed"
+    (fun _typ cid creator indexed_at labels like_count policies reason_types subject_collections subject_types uri viewer -> { cid; creator; indexed_at; labels; like_count; policies; reason_types; subject_collections; subject_types; uri; viewer })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerViewDetailed" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerViewDetailed")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
+  |> Jsont.Object.mem "policies" Jsont.json ~enc:(fun r -> r.policies)
+  |> Jsont.Object.opt_mem "reasonTypes" (Jsont.list Com.Atproto.Moderation.Defs.reason_type_jsont) ~enc:(fun r -> r.reason_types)
+  |> Jsont.Object.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
+  |> Jsont.Object.opt_mem "subjectTypes" (Jsont.list Com.Atproto.Moderation.Defs.subject_type_jsont) ~enc:(fun r -> r.subject_types)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
+  |> Jsont.Object.finish
+
+type labeler_view = {
+  cid : string;
+  creator : Jsont.json;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  uri : string;
+  viewer : Jsont.json option;
+}
+
+let labeler_view_jsont =
+  Jsont.Object.map ~kind:"Labeler_view"
+    (fun _typ cid creator indexed_at labels like_count uri viewer -> { cid; creator; indexed_at; labels; like_count; uri; viewer })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerView" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerView")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
+  |> Jsont.Object.finish
+
+      end
+      module Service = struct
+type main = {
+  created_at : string;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  policies : Jsont.json;
+  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;
+  subject_collections : string list option;
+  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at labels policies reason_types subject_collections subject_types -> { created_at; labels; policies; reason_types; subject_collections; subject_types })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.service" ~enc:(fun _ -> "app.bsky.labeler.service")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> Jsont.Object.mem "policies" Jsont.json ~enc:(fun r -> r.policies)
+  |> Jsont.Object.opt_mem "reasonTypes" (Jsont.list Com.Atproto.Moderation.Defs.reason_type_jsont) ~enc:(fun r -> r.reason_types)
+  |> Jsont.Object.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
+  |> Jsont.Object.opt_mem "subjectTypes" (Jsont.list Com.Atproto.Moderation.Defs.subject_type_jsont) ~enc:(fun r -> r.subject_types)
+  |> Jsont.Object.finish
+
+      end
+      module GetServices = struct
+type params = {
+  detailed : bool option;
+  dids : string list;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun detailed dids -> {
+      detailed;
+      dids;
+    })
+  |> Jsont.Object.opt_mem "detailed" Jsont.bool
+       ~enc:(fun r -> r.detailed)
+  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.dids)
+  |> Jsont.Object.finish
+
+type output = {
+  views : Jsont.json list;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ views -> { views })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.getServices#output" ~enc:(fun _ -> "app.bsky.labeler.getServices#output")
+  |> Jsont.Object.mem "views" (Jsont.list Jsont.json) ~enc:(fun r -> r.views)
+  |> Jsont.Object.finish
+
+      end
+    end
+    module AuthCreatePosts = struct
 type main = unit
 let main_jsont = Jsont.ignore
 
     end
-    module Notification = struct
-      module GetUnreadCount = struct
+    module Video = struct
+      module GetUploadLimits = struct
+type output = {
+  can_upload : bool;
+  error : string option;
+  message : string option;
+  remaining_daily_bytes : int option;
+  remaining_daily_videos : int option;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ can_upload error message remaining_daily_bytes remaining_daily_videos -> { can_upload; error; message; remaining_daily_bytes; remaining_daily_videos })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.getUploadLimits#output" ~enc:(fun _ -> "app.bsky.video.getUploadLimits#output")
+  |> Jsont.Object.mem "canUpload" Jsont.bool ~enc:(fun r -> r.can_upload)
+  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+  |> Jsont.Object.opt_mem "remainingDailyBytes" Jsont.int ~enc:(fun r -> r.remaining_daily_bytes)
+  |> Jsont.Object.opt_mem "remainingDailyVideos" Jsont.int ~enc:(fun r -> r.remaining_daily_videos)
+  |> Jsont.Object.finish
+
+      end
+      module Defs = struct
+type job_status = {
+  blob : Atp.Blob_ref.t option;
+  did : string;
+  error : string option;
+  job_id : string;
+  message : string option;
+  progress : int option;
+  state : string;
+}
+
+let job_status_jsont =
+  Jsont.Object.map ~kind:"Job_status"
+    (fun _typ blob did error job_id message progress state -> { blob; did; error; job_id; message; progress; state })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.defs#jobStatus" ~enc:(fun _ -> "app.bsky.video.defs#jobStatus")
+  |> Jsont.Object.opt_mem "blob" Atp.Blob_ref.jsont ~enc:(fun r -> r.blob)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.mem "jobId" Jsont.string ~enc:(fun r -> r.job_id)
+  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+  |> Jsont.Object.opt_mem "progress" Jsont.int ~enc:(fun r -> r.progress)
+  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
+  |> Jsont.Object.finish
+
+      end
+      module UploadVideo = struct
+type input = unit
+let input_jsont = Jsont.ignore
+
+type output = {
+  job_status : Defs.job_status;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ job_status -> { job_status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.uploadVideo#output" ~enc:(fun _ -> "app.bsky.video.uploadVideo#output")
+  |> Jsont.Object.mem "jobStatus" Defs.job_status_jsont ~enc:(fun r -> r.job_status)
+  |> Jsont.Object.finish
+
+      end
+      module GetJobStatus = struct
 type params = {
-  priority : bool option;
-  seen_at : string option;
+  job_id : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun priority seen_at -> {
-      priority;
-      seen_at;
+    (fun job_id -> {
+      job_id;
     })
-  |> Jsont.Object.opt_mem "priority" Jsont.bool
-       ~enc:(fun r -> r.priority)
-  |> Jsont.Object.opt_mem "seenAt" Jsont.string
-       ~enc:(fun r -> r.seen_at)
+  |> Jsont.Object.mem "jobId" Jsont.string
+       ~enc:(fun r -> r.job_id)
   |> Jsont.Object.finish
 
 type output = {
-  count : int;
+  job_status : Defs.job_status;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ count -> { count })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.getUnreadCount#output" ~enc:(fun _ -> "app.bsky.notification.getUnreadCount#output")
-  |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
+    (fun _typ job_status -> { job_status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.getJobStatus#output" ~enc:(fun _ -> "app.bsky.video.getJobStatus#output")
+  |> Jsont.Object.mem "jobStatus" Defs.job_status_jsont ~enc:(fun r -> r.job_status)
   |> Jsont.Object.finish
 
       end
+    end
+    module Embed = struct
+      module External = struct
+type view_external = {
+  description : string;
+  thumb : string option;
+  title : string;
+  uri : string;
+}
+
+let view_external_jsont =
+  Jsont.Object.map ~kind:"View_external"
+    (fun _typ description thumb title uri -> { description; thumb; title; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#viewExternal" ~enc:(fun _ -> "app.bsky.embed.external#viewExternal")
+  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "thumb" Jsont.string ~enc:(fun r -> r.thumb)
+  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type external_ = {
+  description : string;
+  thumb : Atp.Blob_ref.t option;
+  title : string;
+  uri : string;
+}
+
+let external__jsont =
+  Jsont.Object.map ~kind:"External_"
+    (fun _typ description thumb title uri -> { description; thumb; title; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#external" ~enc:(fun _ -> "app.bsky.embed.external#external")
+  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "thumb" Atp.Blob_ref.jsont ~enc:(fun r -> r.thumb)
+  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type view = {
+  external_ : Jsont.json;
+}
+
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
+    (fun _typ external_ -> { external_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#view" ~enc:(fun _ -> "app.bsky.embed.external#view")
+  |> Jsont.Object.mem "external" Jsont.json ~enc:(fun r -> r.external_)
+  |> Jsont.Object.finish
+
+type main = {
+  external_ : Jsont.json;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ external_ -> { external_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external" ~enc:(fun _ -> "app.bsky.embed.external")
+  |> Jsont.Object.mem "external" Jsont.json ~enc:(fun r -> r.external_)
+  |> Jsont.Object.finish
+
+      end
+      module Defs = struct
+type aspect_ratio = {
+  height : int;
+  width : int;
+}
+
+let aspect_ratio_jsont =
+  Jsont.Object.map ~kind:"Aspect_ratio"
+    (fun _typ height width -> { height; width })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.defs#aspectRatio" ~enc:(fun _ -> "app.bsky.embed.defs#aspectRatio")
+  |> Jsont.Object.mem "height" Jsont.int ~enc:(fun r -> r.height)
+  |> Jsont.Object.mem "width" Jsont.int ~enc:(fun r -> r.width)
+  |> Jsont.Object.finish
+
+      end
+      module Images = struct
+type view_image = {
+  alt : string;
+  aspect_ratio : Jsont.json option;
+  fullsize : string;
+  thumb : string;
+}
+
+let view_image_jsont =
+  Jsont.Object.map ~kind:"View_image"
+    (fun _typ alt aspect_ratio fullsize thumb -> { alt; aspect_ratio; fullsize; thumb })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#viewImage" ~enc:(fun _ -> "app.bsky.embed.images#viewImage")
+  |> Jsont.Object.mem "alt" Jsont.string ~enc:(fun r -> r.alt)
+  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
+  |> Jsont.Object.mem "fullsize" Jsont.string ~enc:(fun r -> r.fullsize)
+  |> Jsont.Object.mem "thumb" Jsont.string ~enc:(fun r -> r.thumb)
+  |> Jsont.Object.finish
+
+type image = {
+  alt : string;
+  aspect_ratio : Jsont.json option;
+  image : Atp.Blob_ref.t;
+}
+
+let image_jsont =
+  Jsont.Object.map ~kind:"Image"
+    (fun _typ alt aspect_ratio image -> { alt; aspect_ratio; image })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#image" ~enc:(fun _ -> "app.bsky.embed.images#image")
+  |> Jsont.Object.mem "alt" Jsont.string ~enc:(fun r -> r.alt)
+  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
+  |> Jsont.Object.mem "image" Atp.Blob_ref.jsont ~enc:(fun r -> r.image)
+  |> Jsont.Object.finish
+
+type view = {
+  images : Jsont.json list;
+}
+
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
+    (fun _typ images -> { images })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#view" ~enc:(fun _ -> "app.bsky.embed.images#view")
+  |> Jsont.Object.mem "images" (Jsont.list Jsont.json) ~enc:(fun r -> r.images)
+  |> Jsont.Object.finish
+
+type main = {
+  images : Jsont.json list;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ images -> { images })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images" ~enc:(fun _ -> "app.bsky.embed.images")
+  |> Jsont.Object.mem "images" (Jsont.list Jsont.json) ~enc:(fun r -> r.images)
+  |> Jsont.Object.finish
+
+      end
+      module Video = struct
+type view = {
+  alt : string option;
+  aspect_ratio : Jsont.json option;
+  cid : string;
+  playlist : string;
+  thumbnail : string option;
+}
+
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
+    (fun _typ alt aspect_ratio cid playlist thumbnail -> { alt; aspect_ratio; cid; playlist; thumbnail })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video#view" ~enc:(fun _ -> "app.bsky.embed.video#view")
+  |> Jsont.Object.opt_mem "alt" Jsont.string ~enc:(fun r -> r.alt)
+  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "playlist" Jsont.string ~enc:(fun r -> r.playlist)
+  |> Jsont.Object.opt_mem "thumbnail" Jsont.string ~enc:(fun r -> r.thumbnail)
+  |> Jsont.Object.finish
+
+type caption = {
+  file : Atp.Blob_ref.t;
+  lang : string;
+}
+
+let caption_jsont =
+  Jsont.Object.map ~kind:"Caption"
+    (fun _typ file lang -> { file; lang })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video#caption" ~enc:(fun _ -> "app.bsky.embed.video#caption")
+  |> Jsont.Object.mem "file" Atp.Blob_ref.jsont ~enc:(fun r -> r.file)
+  |> Jsont.Object.mem "lang" Jsont.string ~enc:(fun r -> r.lang)
+  |> Jsont.Object.finish
+
+type main = {
+  alt : string option;
+  aspect_ratio : Jsont.json option;
+  captions : Jsont.json list option;
+  video : Atp.Blob_ref.t;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ alt aspect_ratio captions video -> { alt; aspect_ratio; captions; video })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video" ~enc:(fun _ -> "app.bsky.embed.video")
+  |> Jsont.Object.opt_mem "alt" Jsont.string ~enc:(fun r -> r.alt)
+  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
+  |> Jsont.Object.opt_mem "captions" (Jsont.list Jsont.json) ~enc:(fun r -> r.captions)
+  |> Jsont.Object.mem "video" Atp.Blob_ref.jsont ~enc:(fun r -> r.video)
+  |> Jsont.Object.finish
+
+      end
+      module RecordWithMedia = struct
+type view = {
+  media : Jsont.json;
+  record : Jsont.json;
+}
+
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
+    (fun _typ media record -> { media; record })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.recordWithMedia#view" ~enc:(fun _ -> "app.bsky.embed.recordWithMedia#view")
+  |> Jsont.Object.mem "media" Jsont.json ~enc:(fun r -> r.media)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.finish
+
+type main = {
+  media : Jsont.json;
+  record : Jsont.json;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ media record -> { media; record })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.recordWithMedia" ~enc:(fun _ -> "app.bsky.embed.recordWithMedia")
+  |> Jsont.Object.mem "media" Jsont.json ~enc:(fun r -> r.media)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.finish
+
+      end
+      module Record = struct
+type view_record = {
+  author : Jsont.json;
+  cid : string;
+  embeds : Jsont.json list option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  quote_count : int option;
+  reply_count : int option;
+  repost_count : int option;
+  uri : string;
+  value : Jsont.json;
+}
+
+let view_record_jsont =
+  Jsont.Object.map ~kind:"View_record"
+    (fun _typ author cid embeds indexed_at labels like_count quote_count reply_count repost_count uri value -> { author; cid; embeds; indexed_at; labels; like_count; quote_count; reply_count; repost_count; uri; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewRecord" ~enc:(fun _ -> "app.bsky.embed.record#viewRecord")
+  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.opt_mem "embeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.embeds)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
+  |> Jsont.Object.opt_mem "quoteCount" Jsont.int ~enc:(fun r -> r.quote_count)
+  |> Jsont.Object.opt_mem "replyCount" Jsont.int ~enc:(fun r -> r.reply_count)
+  |> Jsont.Object.opt_mem "repostCount" Jsont.int ~enc:(fun r -> r.repost_count)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
+  |> Jsont.Object.finish
+
+type view_not_found = {
+  not_found : bool;
+  uri : string;
+}
+
+let view_not_found_jsont =
+  Jsont.Object.map ~kind:"View_not_found"
+    (fun _typ not_found uri -> { not_found; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewNotFound" ~enc:(fun _ -> "app.bsky.embed.record#viewNotFound")
+  |> Jsont.Object.mem "notFound" Jsont.bool ~enc:(fun r -> r.not_found)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type view_detached = {
+  detached : bool;
+  uri : string;
+}
+
+let view_detached_jsont =
+  Jsont.Object.map ~kind:"View_detached"
+    (fun _typ detached uri -> { detached; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewDetached" ~enc:(fun _ -> "app.bsky.embed.record#viewDetached")
+  |> Jsont.Object.mem "detached" Jsont.bool ~enc:(fun r -> r.detached)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type view_blocked = {
+  author : Jsont.json;
+  blocked : bool;
+  uri : string;
+}
+
+let view_blocked_jsont =
+  Jsont.Object.map ~kind:"View_blocked"
+    (fun _typ author blocked uri -> { author; blocked; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewBlocked" ~enc:(fun _ -> "app.bsky.embed.record#viewBlocked")
+  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "blocked" Jsont.bool ~enc:(fun r -> r.blocked)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type view = {
+  record : Jsont.json;
+}
+
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
+    (fun _typ record -> { record })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#view" ~enc:(fun _ -> "app.bsky.embed.record#view")
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.finish
+
+type main = {
+  record : Com.Atproto.Repo.StrongRef.main;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ record -> { record })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record" ~enc:(fun _ -> "app.bsky.embed.record")
+  |> Jsont.Object.mem "record" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.record)
+  |> Jsont.Object.finish
+
+      end
+    end
+    module Notification = struct
       module UpdateSeen = struct
 type input = {
   seen_at : string;
···
     (fun _typ seen_at -> { seen_at })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.updateSeen#input" ~enc:(fun _ -> "app.bsky.notification.updateSeen#input")
   |> Jsont.Object.mem "seenAt" Jsont.string ~enc:(fun r -> r.seen_at)
+  |> Jsont.Object.finish
+
+      end
+      module RegisterPush = struct
+type input = {
+  age_restricted : bool option;
+  app_id : string;
+  platform : string;
+  service_did : string;
+  token : string;
+}
+
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ age_restricted app_id platform service_did token -> { age_restricted; app_id; platform; service_did; token })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.registerPush#input" ~enc:(fun _ -> "app.bsky.notification.registerPush#input")
+  |> Jsont.Object.opt_mem "ageRestricted" Jsont.bool ~enc:(fun r -> r.age_restricted)
+  |> Jsont.Object.mem "appId" Jsont.string ~enc:(fun r -> r.app_id)
+  |> Jsont.Object.mem "platform" Jsont.string ~enc:(fun r -> r.platform)
+  |> Jsont.Object.mem "serviceDid" Jsont.string ~enc:(fun r -> r.service_did)
+  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module Declaration = struct
-type main = {
-  allow_subscriptions : string;
+      module GetUnreadCount = struct
+type params = {
+  priority : bool option;
+  seen_at : string option;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ allow_subscriptions -> { allow_subscriptions })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.declaration" ~enc:(fun _ -> "app.bsky.notification.declaration")
-  |> Jsont.Object.mem "allowSubscriptions" Jsont.string ~enc:(fun r -> r.allow_subscriptions)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun priority seen_at -> {
+      priority;
+      seen_at;
+    })
+  |> Jsont.Object.opt_mem "priority" Jsont.bool
+       ~enc:(fun r -> r.priority)
+  |> Jsont.Object.opt_mem "seenAt" Jsont.string
+       ~enc:(fun r -> r.seen_at)
   |> Jsont.Object.finish
 
-      end
-      module PutPreferences = struct
-type input = {
-  priority : bool;
+type output = {
+  count : int;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ priority -> { priority })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.putPreferences#input" ~enc:(fun _ -> "app.bsky.notification.putPreferences#input")
-  |> Jsont.Object.mem "priority" Jsont.bool ~enc:(fun r -> r.priority)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ count -> { count })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.getUnreadCount#output" ~enc:(fun _ -> "app.bsky.notification.getUnreadCount#output")
+  |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
   |> Jsont.Object.finish
 
       end
-      module RegisterPush = struct
+      module UnregisterPush = struct
 type input = {
-  age_restricted : bool option;
   app_id : string;
   platform : string;
   service_did : string;
···
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ age_restricted app_id platform service_did token -> { age_restricted; app_id; platform; service_did; token })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.registerPush#input" ~enc:(fun _ -> "app.bsky.notification.registerPush#input")
-  |> Jsont.Object.opt_mem "ageRestricted" Jsont.bool ~enc:(fun r -> r.age_restricted)
+    (fun _typ app_id platform service_did token -> { app_id; platform; service_did; token })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.unregisterPush#input" ~enc:(fun _ -> "app.bsky.notification.unregisterPush#input")
   |> Jsont.Object.mem "appId" Jsont.string ~enc:(fun r -> r.app_id)
   |> Jsont.Object.mem "platform" Jsont.string ~enc:(fun r -> r.platform)
   |> Jsont.Object.mem "serviceDid" Jsont.string ~enc:(fun r -> r.service_did)
···
   |> Jsont.Object.finish
 
       end
-      module UnregisterPush = struct
+      module PutPreferences = struct
 type input = {
-  app_id : string;
-  platform : string;
-  service_did : string;
-  token : string;
+  priority : bool;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ app_id platform service_did token -> { app_id; platform; service_did; token })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.unregisterPush#input" ~enc:(fun _ -> "app.bsky.notification.unregisterPush#input")
-  |> Jsont.Object.mem "appId" Jsont.string ~enc:(fun r -> r.app_id)
-  |> Jsont.Object.mem "platform" Jsont.string ~enc:(fun r -> r.platform)
-  |> Jsont.Object.mem "serviceDid" Jsont.string ~enc:(fun r -> r.service_did)
-  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
+    (fun _typ priority -> { priority })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.putPreferences#input" ~enc:(fun _ -> "app.bsky.notification.putPreferences#input")
+  |> Jsont.Object.mem "priority" Jsont.bool ~enc:(fun r -> r.priority)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
+      module Declaration = struct
+type main = {
+  allow_subscriptions : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ allow_subscriptions -> { allow_subscriptions })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.declaration" ~enc:(fun _ -> "app.bsky.notification.declaration")
+  |> Jsont.Object.mem "allowSubscriptions" Jsont.string ~enc:(fun r -> r.allow_subscriptions)
+  |> Jsont.Object.finish
+
+      end
       module ListActivitySubscriptions = struct
 type params = {
   cursor : string option;
···
 
       end
     end
-    module Labeler = struct
-      module Defs = struct
-type labeler_viewer_state = {
-  like : string option;
-}
-
-let labeler_viewer_state_jsont =
-  Jsont.Object.map ~kind:"Labeler_viewer_state"
-    (fun _typ like -> { like })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerViewerState" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerViewerState")
-  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
-  |> Jsont.Object.finish
-
-type labeler_policies = {
-  label_value_definitions : Com.Atproto.Label.Defs.label_value_definition list option;
-  label_values : Com.Atproto.Label.Defs.label_value list;
-}
-
-let labeler_policies_jsont =
-  Jsont.Object.map ~kind:"Labeler_policies"
-    (fun _typ label_value_definitions label_values -> { label_value_definitions; label_values })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerPolicies" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerPolicies")
-  |> Jsont.Object.opt_mem "labelValueDefinitions" (Jsont.list Com.Atproto.Label.Defs.label_value_definition_jsont) ~enc:(fun r -> r.label_value_definitions)
-  |> Jsont.Object.mem "labelValues" (Jsont.list Com.Atproto.Label.Defs.label_value_jsont) ~enc:(fun r -> r.label_values)
-  |> Jsont.Object.finish
-
-type labeler_view_detailed = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  policies : Jsont.json;
-  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;
-  subject_collections : string list option;
-  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-let labeler_view_detailed_jsont =
-  Jsont.Object.map ~kind:"Labeler_view_detailed"
-    (fun _typ cid creator indexed_at labels like_count policies reason_types subject_collections subject_types uri viewer -> { cid; creator; indexed_at; labels; like_count; policies; reason_types; subject_collections; subject_types; uri; viewer })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerViewDetailed" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerViewDetailed")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
-  |> Jsont.Object.mem "policies" Jsont.json ~enc:(fun r -> r.policies)
-  |> Jsont.Object.opt_mem "reasonTypes" (Jsont.list Com.Atproto.Moderation.Defs.reason_type_jsont) ~enc:(fun r -> r.reason_types)
-  |> Jsont.Object.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
-  |> Jsont.Object.opt_mem "subjectTypes" (Jsont.list Com.Atproto.Moderation.Defs.subject_type_jsont) ~enc:(fun r -> r.subject_types)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type labeler_view = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-let labeler_view_jsont =
-  Jsont.Object.map ~kind:"Labeler_view"
-    (fun _typ cid creator indexed_at labels like_count uri viewer -> { cid; creator; indexed_at; labels; like_count; uri; viewer })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerView" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerView")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-      end
-      module Service = struct
-type main = {
-  created_at : string;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  policies : Jsont.json;
-  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;
-  subject_collections : string list option;
-  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at labels policies reason_types subject_collections subject_types -> { created_at; labels; policies; reason_types; subject_collections; subject_types })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.service" ~enc:(fun _ -> "app.bsky.labeler.service")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
-  |> Jsont.Object.mem "policies" Jsont.json ~enc:(fun r -> r.policies)
-  |> Jsont.Object.opt_mem "reasonTypes" (Jsont.list Com.Atproto.Moderation.Defs.reason_type_jsont) ~enc:(fun r -> r.reason_types)
-  |> Jsont.Object.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
-  |> Jsont.Object.opt_mem "subjectTypes" (Jsont.list Com.Atproto.Moderation.Defs.subject_type_jsont) ~enc:(fun r -> r.subject_types)
-  |> Jsont.Object.finish
-
-      end
-      module GetServices = struct
-type params = {
-  detailed : bool option;
-  dids : string list;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun detailed dids -> {
-      detailed;
-      dids;
-    })
-  |> Jsont.Object.opt_mem "detailed" Jsont.bool
-       ~enc:(fun r -> r.detailed)
-  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.dids)
-  |> Jsont.Object.finish
-
-type output = {
-  views : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ views -> { views })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.getServices#output" ~enc:(fun _ -> "app.bsky.labeler.getServices#output")
-  |> Jsont.Object.mem "views" (Jsont.list Jsont.json) ~enc:(fun r -> r.views)
-  |> Jsont.Object.finish
-
-      end
-    end
     module Actor = struct
       module Status = struct
 type live = string
···
   |> Jsont.Object.opt_mem "durationMinutes" Jsont.int ~enc:(fun r -> r.duration_minutes)
   |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
   |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.finish
+
+      end
+      module Profile = struct
+type main = {
+  avatar : Atp.Blob_ref.t option;
+  banner : Atp.Blob_ref.t option;
+  created_at : string option;
+  description : string option;
+  display_name : string option;
+  joined_via_starter_pack : Com.Atproto.Repo.StrongRef.main option;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  pinned_post : Com.Atproto.Repo.StrongRef.main option;
+  pronouns : string option;
+  website : string option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ avatar banner created_at description display_name joined_via_starter_pack labels pinned_post pronouns website -> { avatar; banner; created_at; description; display_name; joined_via_starter_pack; labels; pinned_post; pronouns; website })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.profile" ~enc:(fun _ -> "app.bsky.actor.profile")
+  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.opt_mem "banner" Atp.Blob_ref.jsont ~enc:(fun r -> r.banner)
+  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+  |> Jsont.Object.opt_mem "joinedViaStarterPack" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.joined_via_starter_pack)
+  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "pinnedPost" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.pinned_post)
+  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
+  |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module Profile = struct
-type main = {
-  avatar : Atp.Blob_ref.t option;
-  banner : Atp.Blob_ref.t option;
-  created_at : string option;
-  description : string option;
-  display_name : string option;
-  joined_via_starter_pack : Com.Atproto.Repo.StrongRef.main option;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  pinned_post : Com.Atproto.Repo.StrongRef.main option;
-  pronouns : string option;
-  website : string option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ avatar banner created_at description display_name joined_via_starter_pack labels pinned_post pronouns website -> { avatar; banner; created_at; description; display_name; joined_via_starter_pack; labels; pinned_post; pronouns; website })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.profile" ~enc:(fun _ -> "app.bsky.actor.profile")
-  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "banner" Atp.Blob_ref.jsont ~enc:(fun r -> r.banner)
-  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "joinedViaStarterPack" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.joined_via_starter_pack)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "pinnedPost" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.pinned_post)
-  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
-  |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
-  |> Jsont.Object.finish
-
-      end
-      module GetProfiles = struct
-type params = {
-  actors : string list;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun actors -> {
-      actors;
-    })
-  |> Jsont.Object.mem "actors" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.actors)
-  |> Jsont.Object.finish
-
-type output = {
-  profiles : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ profiles -> { profiles })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.getProfiles#output" ~enc:(fun _ -> "app.bsky.actor.getProfiles#output")
-  |> Jsont.Object.mem "profiles" (Jsont.list Jsont.json) ~enc:(fun r -> r.profiles)
-  |> Jsont.Object.finish
-
-      end
       module GetPreferences = struct
 type params = unit
 
···
   |> Jsont.Object.finish
 
       end
-      module GetSuggestions = struct
+      module SearchActorsTypeahead = struct
 type params = {
-  cursor : string option;
   limit : int option;
+  q : string option;
+  term : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
+    (fun limit q term -> {
       limit;
+      q;
+      term;
     })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "q" Jsont.string
+       ~enc:(fun r -> r.q)
+  |> Jsont.Object.opt_mem "term" Jsont.string
+       ~enc:(fun r -> r.term)
   |> Jsont.Object.finish
 
 type output = {
   actors : Jsont.json list;
-  cursor : string option;
-  rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ actors cursor rec_id -> { actors; cursor; rec_id })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.getSuggestions#output" ~enc:(fun _ -> "app.bsky.actor.getSuggestions#output")
+    (fun _typ actors -> { actors })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.searchActorsTypeahead#output" ~enc:(fun _ -> "app.bsky.actor.searchActorsTypeahead#output")
   |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module PutPreferences = struct
-type input = {
-  preferences : Jsont.json;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ preferences -> { preferences })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.putPreferences#input" ~enc:(fun _ -> "app.bsky.actor.putPreferences#input")
-  |> Jsont.Object.mem "preferences" Jsont.json ~enc:(fun r -> r.preferences)
-  |> Jsont.Object.finish
-
-      end
-      module SearchActorsTypeahead = struct
+      module GetSuggestions = struct
 type params = {
+  cursor : string option;
   limit : int option;
-  q : string option;
-  term : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit q term -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      q;
-      term;
     })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "q" Jsont.string
-       ~enc:(fun r -> r.q)
-  |> Jsont.Object.opt_mem "term" Jsont.string
-       ~enc:(fun r -> r.term)
   |> Jsont.Object.finish
 
 type output = {
   actors : Jsont.json list;
+  cursor : string option;
+  rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ actors -> { actors })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.searchActorsTypeahead#output" ~enc:(fun _ -> "app.bsky.actor.searchActorsTypeahead#output")
+    (fun _typ actors cursor rec_id -> { actors; cursor; rec_id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.getSuggestions#output" ~enc:(fun _ -> "app.bsky.actor.getSuggestions#output")
   |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
   |> Jsont.Object.finish
 
       end
-    end
-    module Video = struct
-      module GetUploadLimits = struct
+      module GetProfiles = struct
+type params = {
+  actors : string list;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actors -> {
+      actors;
+    })
+  |> Jsont.Object.mem "actors" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.actors)
+  |> Jsont.Object.finish
+
 type output = {
-  can_upload : bool;
-  error : string option;
-  message : string option;
-  remaining_daily_bytes : int option;
-  remaining_daily_videos : int option;
+  profiles : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ can_upload error message remaining_daily_bytes remaining_daily_videos -> { can_upload; error; message; remaining_daily_bytes; remaining_daily_videos })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.getUploadLimits#output" ~enc:(fun _ -> "app.bsky.video.getUploadLimits#output")
-  |> Jsont.Object.mem "canUpload" Jsont.bool ~enc:(fun r -> r.can_upload)
-  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
-  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.opt_mem "remainingDailyBytes" Jsont.int ~enc:(fun r -> r.remaining_daily_bytes)
-  |> Jsont.Object.opt_mem "remainingDailyVideos" Jsont.int ~enc:(fun r -> r.remaining_daily_videos)
+    (fun _typ profiles -> { profiles })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.getProfiles#output" ~enc:(fun _ -> "app.bsky.actor.getProfiles#output")
+  |> Jsont.Object.mem "profiles" (Jsont.list Jsont.json) ~enc:(fun r -> r.profiles)
+  |> Jsont.Object.finish
+
+      end
+      module PutPreferences = struct
+type input = {
+  preferences : Jsont.json;
+}
+
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ preferences -> { preferences })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.putPreferences#input" ~enc:(fun _ -> "app.bsky.actor.putPreferences#input")
+  |> Jsont.Object.mem "preferences" Jsont.json ~enc:(fun r -> r.preferences)
   |> Jsont.Object.finish
 
       end
+    end
+    module Contact = struct
       module Defs = struct
-type job_status = {
-  blob : Atp.Blob_ref.t option;
-  did : string;
-  error : string option;
-  job_id : string;
-  message : string option;
-  progress : int option;
-  state : string;
+type sync_status = {
+  matches_count : int;
+  synced_at : string;
+}
+
+let sync_status_jsont =
+  Jsont.Object.map ~kind:"Sync_status"
+    (fun _typ matches_count synced_at -> { matches_count; synced_at })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#syncStatus" ~enc:(fun _ -> "app.bsky.contact.defs#syncStatus")
+  |> Jsont.Object.mem "matchesCount" Jsont.int ~enc:(fun r -> r.matches_count)
+  |> Jsont.Object.mem "syncedAt" Jsont.string ~enc:(fun r -> r.synced_at)
+  |> Jsont.Object.finish
+
+type notification = {
+  from : string;
+  to_ : string;
 }
 
-let job_status_jsont =
-  Jsont.Object.map ~kind:"Job_status"
-    (fun _typ blob did error job_id message progress state -> { blob; did; error; job_id; message; progress; state })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.defs#jobStatus" ~enc:(fun _ -> "app.bsky.video.defs#jobStatus")
-  |> Jsont.Object.opt_mem "blob" Atp.Blob_ref.jsont ~enc:(fun r -> r.blob)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
-  |> Jsont.Object.mem "jobId" Jsont.string ~enc:(fun r -> r.job_id)
-  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.opt_mem "progress" Jsont.int ~enc:(fun r -> r.progress)
-  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
+let notification_jsont =
+  Jsont.Object.map ~kind:"Notification"
+    (fun _typ from to_ -> { from; to_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#notification" ~enc:(fun _ -> "app.bsky.contact.defs#notification")
+  |> Jsont.Object.mem "from" Jsont.string ~enc:(fun r -> r.from)
+  |> Jsont.Object.mem "to" Jsont.string ~enc:(fun r -> r.to_)
+  |> Jsont.Object.finish
+
+type match_and_contact_index = {
+  contact_index : int;
+  match_ : Jsont.json;
+}
+
+let match_and_contact_index_jsont =
+  Jsont.Object.map ~kind:"Match_and_contact_index"
+    (fun _typ contact_index match_ -> { contact_index; match_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#matchAndContactIndex" ~enc:(fun _ -> "app.bsky.contact.defs#matchAndContactIndex")
+  |> Jsont.Object.mem "contactIndex" Jsont.int ~enc:(fun r -> r.contact_index)
+  |> Jsont.Object.mem "match" Jsont.json ~enc:(fun r -> r.match_)
+  |> Jsont.Object.finish
+
+      end
+      module RemoveData = struct
+type input = unit
+
+let input_jsont = Jsont.ignore
+
+type output = unit
+
+let output_jsont = Jsont.ignore
+
+      end
+      module DismissMatch = struct
+type input = {
+  subject : string;
+}
+
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ subject -> { subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.dismissMatch#input" ~enc:(fun _ -> "app.bsky.contact.dismissMatch#input")
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
+type output = unit
+
+let output_jsont = Jsont.ignore
+
       end
-      module GetJobStatus = struct
+      module GetMatches = struct
 type params = {
-  job_id : string;
+  cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun job_id -> {
-      job_id;
+    (fun cursor limit -> {
+      cursor;
+      limit;
     })
-  |> Jsont.Object.mem "jobId" Jsont.string
-       ~enc:(fun r -> r.job_id)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
-  job_status : Defs.job_status;
+  cursor : string option;
+  matches : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ job_status -> { job_status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.getJobStatus#output" ~enc:(fun _ -> "app.bsky.video.getJobStatus#output")
-  |> Jsont.Object.mem "jobStatus" Defs.job_status_jsont ~enc:(fun r -> r.job_status)
+    (fun _typ cursor matches -> { cursor; matches })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.getMatches#output" ~enc:(fun _ -> "app.bsky.contact.getMatches#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "matches" (Jsont.list Jsont.json) ~enc:(fun r -> r.matches)
   |> Jsont.Object.finish
 
       end
-      module UploadVideo = struct
-type input = unit
-let input_jsont = Jsont.ignore
+      module VerifyPhone = struct
+type input = {
+  code : string;
+  phone : string;
+}
+
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ code phone -> { code; phone })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.verifyPhone#input" ~enc:(fun _ -> "app.bsky.contact.verifyPhone#input")
+  |> Jsont.Object.mem "code" Jsont.string ~enc:(fun r -> r.code)
+  |> Jsont.Object.mem "phone" Jsont.string ~enc:(fun r -> r.phone)
+  |> Jsont.Object.finish
 
 type output = {
-  job_status : Defs.job_status;
+  token : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ job_status -> { job_status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.video.uploadVideo#output" ~enc:(fun _ -> "app.bsky.video.uploadVideo#output")
-  |> Jsont.Object.mem "jobStatus" Defs.job_status_jsont ~enc:(fun r -> r.job_status)
+    (fun _typ token -> { token })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.verifyPhone#output" ~enc:(fun _ -> "app.bsky.contact.verifyPhone#output")
+  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
   |> Jsont.Object.finish
 
       end
-    end
-    module Richtext = struct
-      module Facet = struct
-type tag = {
-  tag : string;
-}
-
-let tag_jsont =
-  Jsont.Object.map ~kind:"Tag"
-    (fun _typ tag -> { tag })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#tag" ~enc:(fun _ -> "app.bsky.richtext.facet#tag")
-  |> Jsont.Object.mem "tag" Jsont.string ~enc:(fun r -> r.tag)
-  |> Jsont.Object.finish
-
-type mention = {
-  did : string;
+      module StartPhoneVerification = struct
+type input = {
+  phone : string;
 }
 
-let mention_jsont =
-  Jsont.Object.map ~kind:"Mention"
-    (fun _typ did -> { did })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#mention" ~enc:(fun _ -> "app.bsky.richtext.facet#mention")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ phone -> { phone })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.startPhoneVerification#input" ~enc:(fun _ -> "app.bsky.contact.startPhoneVerification#input")
+  |> Jsont.Object.mem "phone" Jsont.string ~enc:(fun r -> r.phone)
   |> Jsont.Object.finish
 
-type link = {
-  uri : string;
-}
+type output = unit
 
-let link_jsont =
-  Jsont.Object.map ~kind:"Link"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#link" ~enc:(fun _ -> "app.bsky.richtext.facet#link")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
+let output_jsont = Jsont.ignore
 
-type byte_slice = {
-  byte_end : int;
-  byte_start : int;
+      end
+      module SendNotification = struct
+type input = {
+  from : string;
+  to_ : string;
 }
 
-let byte_slice_jsont =
-  Jsont.Object.map ~kind:"Byte_slice"
-    (fun _typ byte_end byte_start -> { byte_end; byte_start })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet#byteSlice" ~enc:(fun _ -> "app.bsky.richtext.facet#byteSlice")
-  |> Jsont.Object.mem "byteEnd" Jsont.int ~enc:(fun r -> r.byte_end)
-  |> Jsont.Object.mem "byteStart" Jsont.int ~enc:(fun r -> r.byte_start)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ from to_ -> { from; to_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.sendNotification#input" ~enc:(fun _ -> "app.bsky.contact.sendNotification#input")
+  |> Jsont.Object.mem "from" Jsont.string ~enc:(fun r -> r.from)
+  |> Jsont.Object.mem "to" Jsont.string ~enc:(fun r -> r.to_)
   |> Jsont.Object.finish
 
-type main = {
-  features : Jsont.json list;
-  index : byte_slice;
-}
+type output = unit
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ features index -> { features; index })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.richtext.facet" ~enc:(fun _ -> "app.bsky.richtext.facet")
-  |> Jsont.Object.mem "features" (Jsont.list Jsont.json) ~enc:(fun r -> r.features)
-  |> Jsont.Object.mem "index" byte_slice_jsont ~enc:(fun r -> r.index)
-  |> Jsont.Object.finish
+let output_jsont = Jsont.ignore
 
       end
-    end
-    module AuthCreatePosts = struct
-type main = unit
-let main_jsont = Jsont.ignore
+      module GetSyncStatus = struct
+type params = unit
 
-    end
-    module Ageassurance = struct
-      module Defs = struct
-type status = string
-let status_jsont = Jsont.string
+let params_jsont = Jsont.ignore
 
-type state_metadata = {
-  account_created_at : string option;
+type output = {
+  sync_status : Defs.sync_status option;
 }
 
-let state_metadata_jsont =
-  Jsont.Object.map ~kind:"State_metadata"
-    (fun _typ account_created_at -> { account_created_at })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#stateMetadata" ~enc:(fun _ -> "app.bsky.ageassurance.defs#stateMetadata")
-  |> Jsont.Object.opt_mem "accountCreatedAt" Jsont.string ~enc:(fun r -> r.account_created_at)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ sync_status -> { sync_status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.getSyncStatus#output" ~enc:(fun _ -> "app.bsky.contact.getSyncStatus#output")
+  |> Jsont.Object.opt_mem "syncStatus" Defs.sync_status_jsont ~enc:(fun r -> r.sync_status)
   |> Jsont.Object.finish
 
-type event = {
-  access : string;
-  attempt_id : string;
-  complete_ip : string option;
-  complete_ua : string option;
-  country_code : string;
-  created_at : string;
-  email : string option;
-  init_ip : string option;
-  init_ua : string option;
-  region_code : string option;
-  status : string;
+      end
+      module ImportContacts = struct
+type input = {
+  contacts : string list;
+  token : string;
 }
 
-let event_jsont =
-  Jsont.Object.map ~kind:"Event"
-    (fun _typ access attempt_id complete_ip complete_ua country_code created_at email init_ip init_ua region_code status -> { access; attempt_id; complete_ip; complete_ua; country_code; created_at; email; init_ip; init_ua; region_code; status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#event" ~enc:(fun _ -> "app.bsky.ageassurance.defs#event")
-  |> Jsont.Object.mem "access" Jsont.string ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "attemptId" Jsont.string ~enc:(fun r -> r.attempt_id)
-  |> Jsont.Object.opt_mem "completeIp" Jsont.string ~enc:(fun r -> r.complete_ip)
-  |> Jsont.Object.opt_mem "completeUa" Jsont.string ~enc:(fun r -> r.complete_ua)
-  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.opt_mem "initIp" Jsont.string ~enc:(fun r -> r.init_ip)
-  |> Jsont.Object.opt_mem "initUa" Jsont.string ~enc:(fun r -> r.init_ua)
-  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ contacts token -> { contacts; token })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.importContacts#input" ~enc:(fun _ -> "app.bsky.contact.importContacts#input")
+  |> Jsont.Object.mem "contacts" (Jsont.list Jsont.string) ~enc:(fun r -> r.contacts)
+  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
   |> Jsont.Object.finish
 
-type config_region = {
-  country_code : string;
-  min_access_age : int;
-  region_code : string option;
-  rules : Jsont.json list;
+type output = {
+  matches_and_contact_indexes : Defs.match_and_contact_index list;
 }
 
-let config_region_jsont =
-  Jsont.Object.map ~kind:"Config_region"
-    (fun _typ country_code min_access_age region_code rules -> { country_code; min_access_age; region_code; rules })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegion" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegion")
-  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
-  |> Jsont.Object.mem "minAccessAge" Jsont.int ~enc:(fun r -> r.min_access_age)
-  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
-  |> Jsont.Object.mem "rules" (Jsont.list Jsont.json) ~enc:(fun r -> r.rules)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ matches_and_contact_indexes -> { matches_and_contact_indexes })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.importContacts#output" ~enc:(fun _ -> "app.bsky.contact.importContacts#output")
+  |> Jsont.Object.mem "matchesAndContactIndexes" (Jsont.list Defs.match_and_contact_index_jsont) ~enc:(fun r -> r.matches_and_contact_indexes)
   |> Jsont.Object.finish
 
-type access = string
-let access_jsont = Jsont.string
-
-type state = {
-  access : access;
-  last_initiated_at : string option;
-  status : status;
+      end
+    end
+    module Graph = struct
+      module Starterpack = struct
+type feed_item = {
+  uri : string;
 }
 
-let state_jsont =
-  Jsont.Object.map ~kind:"State"
-    (fun _typ access last_initiated_at status -> { access; last_initiated_at; status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#state" ~enc:(fun _ -> "app.bsky.ageassurance.defs#state")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.opt_mem "lastInitiatedAt" Jsont.string ~enc:(fun r -> r.last_initiated_at)
-  |> Jsont.Object.mem "status" status_jsont ~enc:(fun r -> r.status)
+let feed_item_jsont =
+  Jsont.Object.map ~kind:"Feed_item"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.starterpack#feedItem" ~enc:(fun _ -> "app.bsky.graph.starterpack#feedItem")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-type config_region_rule_if_declared_under_age = {
-  access : access;
-  age : int;
+type main = {
+  created_at : string;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  feeds : Jsont.json list option;
+  list_ : string;
+  name : string;
 }
 
-let config_region_rule_if_declared_under_age_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_declared_under_age"
-    (fun _typ access age -> { access; age })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at description description_facets feeds list_ name -> { created_at; description; description_facets; feeds; list_; name })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.starterpack" ~enc:(fun _ -> "app.bsky.graph.starterpack")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
+  |> Jsont.Object.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
+  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.finish
 
-type config_region_rule_if_declared_over_age = {
-  access : access;
-  age : int;
+      end
+      module GetFollows = struct
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-let config_region_rule_if_declared_over_age_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_declared_over_age"
-    (fun _typ access age -> { access; age })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor cursor limit -> {
+      actor;
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-type config_region_rule_if_assured_under_age = {
-  access : access;
-  age : int;
+type output = {
+  cursor : string option;
+  follows : Jsont.json list;
+  subject : Jsont.json;
 }
 
-let config_region_rule_if_assured_under_age_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_assured_under_age"
-    (fun _typ access age -> { access; age })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor follows subject -> { cursor; follows; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getFollows#output" ~enc:(fun _ -> "app.bsky.graph.getFollows#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "follows" (Jsont.list Jsont.json) ~enc:(fun r -> r.follows)
+  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
-type config_region_rule_if_assured_over_age = {
-  access : access;
-  age : int;
+      end
+      module GetSuggestedFollowsByActor = struct
+type params = {
+  actor : string;
 }
 
-let config_region_rule_if_assured_over_age_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_assured_over_age"
-    (fun _typ access age -> { access; age })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor -> {
+      actor;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
   |> Jsont.Object.finish
 
-type config_region_rule_if_account_older_than = {
-  access : access;
-  date : string;
+type output = {
+  is_fallback : bool option;
+  rec_id : int option;
+  suggestions : Jsont.json list;
 }
 
-let config_region_rule_if_account_older_than_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_account_older_than"
-    (fun _typ access date -> { access; date })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "date" Jsont.string ~enc:(fun r -> r.date)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ is_fallback rec_id suggestions -> { is_fallback; rec_id; suggestions })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getSuggestedFollowsByActor#output" ~enc:(fun _ -> "app.bsky.graph.getSuggestedFollowsByActor#output")
+  |> Jsont.Object.opt_mem "isFallback" Jsont.bool ~enc:(fun r -> r.is_fallback)
+  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
+  |> Jsont.Object.mem "suggestions" (Jsont.list Jsont.json) ~enc:(fun r -> r.suggestions)
   |> Jsont.Object.finish
 
-type config_region_rule_if_account_newer_than = {
-  access : access;
-  date : string;
+      end
+      module Block = struct
+type main = {
+  created_at : string;
+  subject : string;
 }
 
-let config_region_rule_if_account_newer_than_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_account_newer_than"
-    (fun _typ access date -> { access; date })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
-  |> Jsont.Object.mem "date" Jsont.string ~enc:(fun r -> r.date)
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject -> { created_at; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.block" ~enc:(fun _ -> "app.bsky.graph.block")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
-type config_region_rule_default = {
-  access : access;
+      end
+      module Listblock = struct
+type main = {
+  created_at : string;
+  subject : string;
 }
 
-let config_region_rule_default_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_default"
-    (fun _typ access -> { access })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleDefault" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleDefault")
-  |> Jsont.Object.mem "access" access_jsont ~enc:(fun r -> r.access)
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject -> { created_at; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.listblock" ~enc:(fun _ -> "app.bsky.graph.listblock")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
-type config = {
-  regions : config_region list;
+      end
+      module MuteThread = struct
+type input = {
+  root : string;
 }
 
-let config_jsont =
-  Jsont.Object.map ~kind:"Config"
-    (fun _typ regions -> { regions })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#config" ~enc:(fun _ -> "app.bsky.ageassurance.defs#config")
-  |> Jsont.Object.mem "regions" (Jsont.list config_region_jsont) ~enc:(fun r -> r.regions)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ root -> { root })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteThread#input" ~enc:(fun _ -> "app.bsky.graph.muteThread#input")
+  |> Jsont.Object.mem "root" Jsont.string ~enc:(fun r -> r.root)
   |> Jsont.Object.finish
 
       end
-      module GetState = struct
+      module GetFollowers = struct
 type params = {
-  country_code : string;
-  region_code : string option;
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun country_code region_code -> {
-      country_code;
-      region_code;
+    (fun actor cursor limit -> {
+      actor;
+      cursor;
+      limit;
     })
-  |> Jsont.Object.mem "countryCode" Jsont.string
-       ~enc:(fun r -> r.country_code)
-  |> Jsont.Object.opt_mem "regionCode" Jsont.string
-       ~enc:(fun r -> r.region_code)
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
-  metadata : Defs.state_metadata;
-  state : Defs.state;
+  cursor : string option;
+  followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ metadata state -> { metadata; state })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.getState#output" ~enc:(fun _ -> "app.bsky.ageassurance.getState#output")
-  |> Jsont.Object.mem "metadata" Defs.state_metadata_jsont ~enc:(fun r -> r.metadata)
-  |> Jsont.Object.mem "state" Defs.state_jsont ~enc:(fun r -> r.state)
+    (fun _typ cursor followers subject -> { cursor; followers; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getFollowers#output" ~enc:(fun _ -> "app.bsky.graph.getFollowers#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "followers" (Jsont.list Jsont.json) ~enc:(fun r -> r.followers)
+  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
       end
-      module Begin = struct
+      module UnmuteThread = struct
 type input = {
-  country_code : string;
-  email : string;
-  language : string;
-  region_code : string option;
+  root : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ country_code email language region_code -> { country_code; email; language; region_code })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.begin#input" ~enc:(fun _ -> "app.bsky.ageassurance.begin#input")
-  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
-  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.mem "language" Jsont.string ~enc:(fun r -> r.language)
-  |> Jsont.Object.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
+    (fun _typ root -> { root })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteThread#input" ~enc:(fun _ -> "app.bsky.graph.unmuteThread#input")
+  |> Jsont.Object.mem "root" Jsont.string ~enc:(fun r -> r.root)
   |> Jsont.Object.finish
 
-type output = Defs.state
-
-let output_jsont = Defs.state_jsont
-
       end
-      module GetConfig = struct
-type output = Defs.config
-
-let output_jsont = Defs.config_jsont
-
-      end
-    end
-    module Embed = struct
-      module Defs = struct
-type aspect_ratio = {
-  height : int;
-  width : int;
+      module Follow = struct
+type main = {
+  created_at : string;
+  subject : string;
+  via : Com.Atproto.Repo.StrongRef.main option;
 }
 
-let aspect_ratio_jsont =
-  Jsont.Object.map ~kind:"Aspect_ratio"
-    (fun _typ height width -> { height; width })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.defs#aspectRatio" ~enc:(fun _ -> "app.bsky.embed.defs#aspectRatio")
-  |> Jsont.Object.mem "height" Jsont.int ~enc:(fun r -> r.height)
-  |> Jsont.Object.mem "width" Jsont.int ~enc:(fun r -> r.width)
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject via -> { created_at; subject; via })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.follow" ~enc:(fun _ -> "app.bsky.graph.follow")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
   |> Jsont.Object.finish
 
       end
-      module External = struct
-type view_external = {
-  description : string;
-  thumb : string option;
-  title : string;
-  uri : string;
+      module UnmuteActor = struct
+type input = {
+  actor : string;
 }
 
-let view_external_jsont =
-  Jsont.Object.map ~kind:"View_external"
-    (fun _typ description thumb title uri -> { description; thumb; title; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#viewExternal" ~enc:(fun _ -> "app.bsky.embed.external#viewExternal")
-  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "thumb" Jsont.string ~enc:(fun r -> r.thumb)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ actor -> { actor })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteActor#input" ~enc:(fun _ -> "app.bsky.graph.unmuteActor#input")
+  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
   |> Jsont.Object.finish
 
-type external_ = {
-  description : string;
-  thumb : Atp.Blob_ref.t option;
-  title : string;
-  uri : string;
-}
-
-let external__jsont =
-  Jsont.Object.map ~kind:"External_"
-    (fun _typ description thumb title uri -> { description; thumb; title; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#external" ~enc:(fun _ -> "app.bsky.embed.external#external")
-  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "thumb" Atp.Blob_ref.jsont ~enc:(fun r -> r.thumb)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type view = {
-  external_ : Jsont.json;
+      end
+      module MuteActorList = struct
+type input = {
+  list_ : string;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
-    (fun _typ external_ -> { external_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#view" ~enc:(fun _ -> "app.bsky.embed.external#view")
-  |> Jsont.Object.mem "external" Jsont.json ~enc:(fun r -> r.external_)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ list_ -> { list_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteActorList#input" ~enc:(fun _ -> "app.bsky.graph.muteActorList#input")
+  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
   |> Jsont.Object.finish
 
-type main = {
-  external_ : Jsont.json;
+      end
+      module UnmuteActorList = struct
+type input = {
+  list_ : string;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ external_ -> { external_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external" ~enc:(fun _ -> "app.bsky.embed.external")
-  |> Jsont.Object.mem "external" Jsont.json ~enc:(fun r -> r.external_)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ list_ -> { list_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteActorList#input" ~enc:(fun _ -> "app.bsky.graph.unmuteActorList#input")
+  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
   |> Jsont.Object.finish
 
       end
-      module Images = struct
-type view_image = {
-  alt : string;
-  aspect_ratio : Jsont.json option;
-  fullsize : string;
-  thumb : string;
+      module GetKnownFollowers = struct
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-let view_image_jsont =
-  Jsont.Object.map ~kind:"View_image"
-    (fun _typ alt aspect_ratio fullsize thumb -> { alt; aspect_ratio; fullsize; thumb })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#viewImage" ~enc:(fun _ -> "app.bsky.embed.images#viewImage")
-  |> Jsont.Object.mem "alt" Jsont.string ~enc:(fun r -> r.alt)
-  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
-  |> Jsont.Object.mem "fullsize" Jsont.string ~enc:(fun r -> r.fullsize)
-  |> Jsont.Object.mem "thumb" Jsont.string ~enc:(fun r -> r.thumb)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor cursor limit -> {
+      actor;
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-type image = {
-  alt : string;
-  aspect_ratio : Jsont.json option;
-  image : Atp.Blob_ref.t;
+type output = {
+  cursor : string option;
+  followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
-let image_jsont =
-  Jsont.Object.map ~kind:"Image"
-    (fun _typ alt aspect_ratio image -> { alt; aspect_ratio; image })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#image" ~enc:(fun _ -> "app.bsky.embed.images#image")
-  |> Jsont.Object.mem "alt" Jsont.string ~enc:(fun r -> r.alt)
-  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
-  |> Jsont.Object.mem "image" Atp.Blob_ref.jsont ~enc:(fun r -> r.image)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor followers subject -> { cursor; followers; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getKnownFollowers#output" ~enc:(fun _ -> "app.bsky.graph.getKnownFollowers#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "followers" (Jsont.list Jsont.json) ~enc:(fun r -> r.followers)
+  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
-type view = {
-  images : Jsont.json list;
+      end
+      module MuteActor = struct
+type input = {
+  actor : string;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
-    (fun _typ images -> { images })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#view" ~enc:(fun _ -> "app.bsky.embed.images#view")
-  |> Jsont.Object.mem "images" (Jsont.list Jsont.json) ~enc:(fun r -> r.images)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ actor -> { actor })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteActor#input" ~enc:(fun _ -> "app.bsky.graph.muteActor#input")
+  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
   |> Jsont.Object.finish
 
+      end
+      module Listitem = struct
 type main = {
-  images : Jsont.json list;
+  created_at : string;
+  list_ : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ images -> { images })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images" ~enc:(fun _ -> "app.bsky.embed.images")
-  |> Jsont.Object.mem "images" (Jsont.list Jsont.json) ~enc:(fun r -> r.images)
+    (fun _typ created_at list_ subject -> { created_at; list_; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.listitem" ~enc:(fun _ -> "app.bsky.graph.listitem")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
       end
-      module Video = struct
-type view = {
-  alt : string option;
-  aspect_ratio : Jsont.json option;
+      module Defs = struct
+type starter_pack_view_basic = {
   cid : string;
-  playlist : string;
-  thumbnail : string option;
+  creator : Jsont.json;
+  indexed_at : string;
+  joined_all_time_count : int option;
+  joined_week_count : int option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_item_count : int option;
+  record : Jsont.json;
+  uri : string;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
-    (fun _typ alt aspect_ratio cid playlist thumbnail -> { alt; aspect_ratio; cid; playlist; thumbnail })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video#view" ~enc:(fun _ -> "app.bsky.embed.video#view")
-  |> Jsont.Object.opt_mem "alt" Jsont.string ~enc:(fun r -> r.alt)
-  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
+let starter_pack_view_basic_jsont =
+  Jsont.Object.map ~kind:"Starter_pack_view_basic"
+    (fun _typ cid creator indexed_at joined_all_time_count joined_week_count labels list_item_count record uri -> { cid; creator; indexed_at; joined_all_time_count; joined_week_count; labels; list_item_count; record; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#starterPackViewBasic" ~enc:(fun _ -> "app.bsky.graph.defs#starterPackViewBasic")
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "playlist" Jsont.string ~enc:(fun r -> r.playlist)
-  |> Jsont.Object.opt_mem "thumbnail" Jsont.string ~enc:(fun r -> r.thumbnail)
+  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "joinedAllTimeCount" Jsont.int ~enc:(fun r -> r.joined_all_time_count)
+  |> Jsont.Object.opt_mem "joinedWeekCount" Jsont.int ~enc:(fun r -> r.joined_week_count)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-type caption = {
-  file : Atp.Blob_ref.t;
-  lang : string;
+type relationship = {
+  blocked_by : string option;
+  blocked_by_list : string option;
+  blocking : string option;
+  blocking_by_list : string option;
+  did : string;
+  followed_by : string option;
+  following : string option;
 }
 
-let caption_jsont =
-  Jsont.Object.map ~kind:"Caption"
-    (fun _typ file lang -> { file; lang })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video#caption" ~enc:(fun _ -> "app.bsky.embed.video#caption")
-  |> Jsont.Object.mem "file" Atp.Blob_ref.jsont ~enc:(fun r -> r.file)
-  |> Jsont.Object.mem "lang" Jsont.string ~enc:(fun r -> r.lang)
+let relationship_jsont =
+  Jsont.Object.map ~kind:"Relationship"
+    (fun _typ blocked_by blocked_by_list blocking blocking_by_list did followed_by following -> { blocked_by; blocked_by_list; blocking; blocking_by_list; did; followed_by; following })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#relationship" ~enc:(fun _ -> "app.bsky.graph.defs#relationship")
+  |> Jsont.Object.opt_mem "blockedBy" Jsont.string ~enc:(fun r -> r.blocked_by)
+  |> Jsont.Object.opt_mem "blockedByList" Jsont.string ~enc:(fun r -> r.blocked_by_list)
+  |> Jsont.Object.opt_mem "blocking" Jsont.string ~enc:(fun r -> r.blocking)
+  |> Jsont.Object.opt_mem "blockingByList" Jsont.string ~enc:(fun r -> r.blocking_by_list)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "followedBy" Jsont.string ~enc:(fun r -> r.followed_by)
+  |> Jsont.Object.opt_mem "following" Jsont.string ~enc:(fun r -> r.following)
   |> Jsont.Object.finish
 
-type main = {
-  alt : string option;
-  aspect_ratio : Jsont.json option;
-  captions : Jsont.json list option;
-  video : Atp.Blob_ref.t;
+type referencelist = string
+let referencelist_jsont = Jsont.string
+
+type not_found_actor = {
+  actor : string;
+  not_found : bool;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ alt aspect_ratio captions video -> { alt; aspect_ratio; captions; video })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video" ~enc:(fun _ -> "app.bsky.embed.video")
-  |> Jsont.Object.opt_mem "alt" Jsont.string ~enc:(fun r -> r.alt)
-  |> Jsont.Object.opt_mem "aspectRatio" Jsont.json ~enc:(fun r -> r.aspect_ratio)
-  |> Jsont.Object.opt_mem "captions" (Jsont.list Jsont.json) ~enc:(fun r -> r.captions)
-  |> Jsont.Object.mem "video" Atp.Blob_ref.jsont ~enc:(fun r -> r.video)
+let not_found_actor_jsont =
+  Jsont.Object.map ~kind:"Not_found_actor"
+    (fun _typ actor not_found -> { actor; not_found })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#notFoundActor" ~enc:(fun _ -> "app.bsky.graph.defs#notFoundActor")
+  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
+  |> Jsont.Object.mem "notFound" Jsont.bool ~enc:(fun r -> r.not_found)
   |> Jsont.Object.finish
 
-      end
-      module RecordWithMedia = struct
-type view = {
-  media : Jsont.json;
-  record : Jsont.json;
+type modlist = string
+let modlist_jsont = Jsont.string
+
+type list_viewer_state = {
+  blocked : string option;
+  muted : bool option;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
-    (fun _typ media record -> { media; record })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.recordWithMedia#view" ~enc:(fun _ -> "app.bsky.embed.recordWithMedia#view")
-  |> Jsont.Object.mem "media" Jsont.json ~enc:(fun r -> r.media)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+let list_viewer_state_jsont =
+  Jsont.Object.map ~kind:"List_viewer_state"
+    (fun _typ blocked muted -> { blocked; muted })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listViewerState" ~enc:(fun _ -> "app.bsky.graph.defs#listViewerState")
+  |> Jsont.Object.opt_mem "blocked" Jsont.string ~enc:(fun r -> r.blocked)
+  |> Jsont.Object.opt_mem "muted" Jsont.bool ~enc:(fun r -> r.muted)
   |> Jsont.Object.finish
 
-type main = {
-  media : Jsont.json;
-  record : Jsont.json;
+type list_purpose = string
+let list_purpose_jsont = Jsont.string
+
+type list_item_view = {
+  subject : Jsont.json;
+  uri : string;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ media record -> { media; record })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.recordWithMedia" ~enc:(fun _ -> "app.bsky.embed.recordWithMedia")
-  |> Jsont.Object.mem "media" Jsont.json ~enc:(fun r -> r.media)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+let list_item_view_jsont =
+  Jsont.Object.map ~kind:"List_item_view"
+    (fun _typ subject uri -> { subject; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listItemView" ~enc:(fun _ -> "app.bsky.graph.defs#listItemView")
+  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-      end
-      module Record = struct
-type view_record = {
-  author : Jsont.json;
+type curatelist = string
+let curatelist_jsont = Jsont.string
+
+type list_view_basic = {
+  avatar : string option;
   cid : string;
-  embeds : Jsont.json list option;
-  indexed_at : string;
+  indexed_at : string option;
   labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  quote_count : int option;
-  reply_count : int option;
-  repost_count : int option;
+  list_item_count : int option;
+  name : string;
+  purpose : Jsont.json;
   uri : string;
-  value : Jsont.json;
+  viewer : Jsont.json option;
 }
 
-let view_record_jsont =
-  Jsont.Object.map ~kind:"View_record"
-    (fun _typ author cid embeds indexed_at labels like_count quote_count reply_count repost_count uri value -> { author; cid; embeds; indexed_at; labels; like_count; quote_count; reply_count; repost_count; uri; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewRecord" ~enc:(fun _ -> "app.bsky.embed.record#viewRecord")
-  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
+let list_view_basic_jsont =
+  Jsont.Object.map ~kind:"List_view_basic"
+    (fun _typ avatar cid indexed_at labels list_item_count name purpose uri viewer -> { avatar; cid; indexed_at; labels; list_item_count; name; purpose; uri; viewer })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listViewBasic" ~enc:(fun _ -> "app.bsky.graph.defs#listViewBasic")
+  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "embeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.embeds)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
-  |> Jsont.Object.opt_mem "quoteCount" Jsont.int ~enc:(fun r -> r.quote_count)
-  |> Jsont.Object.opt_mem "replyCount" Jsont.int ~enc:(fun r -> r.reply_count)
-  |> Jsont.Object.opt_mem "repostCount" Jsont.int ~enc:(fun r -> r.repost_count)
+  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
-type view_not_found = {
-  not_found : bool;
+type list_view = {
+  avatar : string option;
+  cid : string;
+  creator : Jsont.json;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_item_count : int option;
+  name : string;
+  purpose : Jsont.json;
   uri : string;
+  viewer : Jsont.json option;
 }
 
-let view_not_found_jsont =
-  Jsont.Object.map ~kind:"View_not_found"
-    (fun _typ not_found uri -> { not_found; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewNotFound" ~enc:(fun _ -> "app.bsky.embed.record#viewNotFound")
-  |> Jsont.Object.mem "notFound" Jsont.bool ~enc:(fun r -> r.not_found)
+let list_view_jsont =
+  Jsont.Object.map ~kind:"List_view"
+    (fun _typ avatar cid creator description description_facets indexed_at labels list_item_count name purpose uri viewer -> { avatar; cid; creator; description; description_facets; indexed_at; labels; list_item_count; name; purpose; uri; viewer })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listView" ~enc:(fun _ -> "app.bsky.graph.defs#listView")
+  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
-type view_detached = {
-  detached : bool;
+type starter_pack_view = {
+  cid : string;
+  creator : Jsont.json;
+  feeds : Jsont.json list option;
+  indexed_at : string;
+  joined_all_time_count : int option;
+  joined_week_count : int option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_ : Jsont.json option;
+  list_items_sample : Jsont.json list option;
+  record : Jsont.json;
   uri : string;
 }
 
-let view_detached_jsont =
-  Jsont.Object.map ~kind:"View_detached"
-    (fun _typ detached uri -> { detached; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewDetached" ~enc:(fun _ -> "app.bsky.embed.record#viewDetached")
-  |> Jsont.Object.mem "detached" Jsont.bool ~enc:(fun r -> r.detached)
+let starter_pack_view_jsont =
+  Jsont.Object.map ~kind:"Starter_pack_view"
+    (fun _typ cid creator feeds indexed_at joined_all_time_count joined_week_count labels list_ list_items_sample record uri -> { cid; creator; feeds; indexed_at; joined_all_time_count; joined_week_count; labels; list_; list_items_sample; record; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#starterPackView" ~enc:(fun _ -> "app.bsky.graph.defs#starterPackView")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
+  |> Jsont.Object.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "joinedAllTimeCount" Jsont.int ~enc:(fun r -> r.joined_all_time_count)
+  |> Jsont.Object.opt_mem "joinedWeekCount" Jsont.int ~enc:(fun r -> r.joined_week_count)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "list" Jsont.json ~enc:(fun r -> r.list_)
+  |> Jsont.Object.opt_mem "listItemsSample" (Jsont.list Jsont.json) ~enc:(fun r -> r.list_items_sample)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-type view_blocked = {
-  author : Jsont.json;
-  blocked : bool;
-  uri : string;
+      end
+      module GetBlocks = struct
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-let view_blocked_jsont =
-  Jsont.Object.map ~kind:"View_blocked"
-    (fun _typ author blocked uri -> { author; blocked; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewBlocked" ~enc:(fun _ -> "app.bsky.embed.record#viewBlocked")
-  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
-  |> Jsont.Object.mem "blocked" Jsont.bool ~enc:(fun r -> r.blocked)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit -> {
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-type view = {
-  record : Jsont.json;
+type output = {
+  blocks : Jsont.json list;
+  cursor : string option;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
-    (fun _typ record -> { record })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#view" ~enc:(fun _ -> "app.bsky.embed.record#view")
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ blocks cursor -> { blocks; cursor })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getBlocks#output" ~enc:(fun _ -> "app.bsky.graph.getBlocks#output")
+  |> Jsont.Object.mem "blocks" (Jsont.list Jsont.json) ~enc:(fun r -> r.blocks)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
+      end
+      module Verification = struct
 type main = {
-  record : Com.Atproto.Repo.StrongRef.main;
+  created_at : string;
+  display_name : string;
+  handle : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ record -> { record })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record" ~enc:(fun _ -> "app.bsky.embed.record")
-  |> Jsont.Object.mem "record" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.record)
+    (fun _typ created_at display_name handle subject -> { created_at; display_name; handle; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.verification" ~enc:(fun _ -> "app.bsky.graph.verification")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
       end
-    end
-    module Contact = struct
-      module SendNotification = struct
-type input = {
-  from : string;
-  to_ : string;
+      module GetMutes = struct
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ from to_ -> { from; to_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.sendNotification#input" ~enc:(fun _ -> "app.bsky.contact.sendNotification#input")
-  |> Jsont.Object.mem "from" Jsont.string ~enc:(fun r -> r.from)
-  |> Jsont.Object.mem "to" Jsont.string ~enc:(fun r -> r.to_)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit -> {
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-type output = unit
+type output = {
+  cursor : string option;
+  mutes : Jsont.json list;
+}
 
-let output_jsont = Jsont.ignore
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor mutes -> { cursor; mutes })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getMutes#output" ~enc:(fun _ -> "app.bsky.graph.getMutes#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "mutes" (Jsont.list Jsont.json) ~enc:(fun r -> r.mutes)
+  |> Jsont.Object.finish
 
       end
-      module StartPhoneVerification = struct
-type input = {
-  phone : string;
+      module GetRelationships = struct
+type params = {
+  actor : string;
+  others : string list option;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ phone -> { phone })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.startPhoneVerification#input" ~enc:(fun _ -> "app.bsky.contact.startPhoneVerification#input")
-  |> Jsont.Object.mem "phone" Jsont.string ~enc:(fun r -> r.phone)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor others -> {
+      actor;
+      others;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "others" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.others)
   |> Jsont.Object.finish
 
-type output = unit
+type output = {
+  actor : string option;
+  relationships : Jsont.json list;
+}
 
-let output_jsont = Jsont.ignore
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ actor relationships -> { actor; relationships })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getRelationships#output" ~enc:(fun _ -> "app.bsky.graph.getRelationships#output")
+  |> Jsont.Object.opt_mem "actor" Jsont.string ~enc:(fun r -> r.actor)
+  |> Jsont.Object.mem "relationships" (Jsont.list Jsont.json) ~enc:(fun r -> r.relationships)
+  |> Jsont.Object.finish
 
       end
-      module GetMatches = struct
+      module GetStarterPacksWithMembership = struct
+type starter_pack_with_membership = {
+  list_item : Jsont.json option;
+  starter_pack : Jsont.json;
+}
+
+let starter_pack_with_membership_jsont =
+  Jsont.Object.map ~kind:"Starter_pack_with_membership"
+    (fun _typ list_item starter_pack -> { list_item; starter_pack })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership" ~enc:(fun _ -> "app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership")
+  |> Jsont.Object.opt_mem "listItem" Jsont.json ~enc:(fun r -> r.list_item)
+  |> Jsont.Object.mem "starterPack" Jsont.json ~enc:(fun r -> r.starter_pack)
+  |> Jsont.Object.finish
+
 type params = {
+  actor : string;
   cursor : string option;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
+    (fun actor cursor limit -> {
+      actor;
       cursor;
       limit;
     })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
···
 
 type output = {
   cursor : string option;
-  matches : Jsont.json list;
+  starter_packs_with_membership : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor matches -> { cursor; matches })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.getMatches#output" ~enc:(fun _ -> "app.bsky.contact.getMatches#output")
+    (fun _typ cursor starter_packs_with_membership -> { cursor; starter_packs_with_membership })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacksWithMembership#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPacksWithMembership#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "matches" (Jsont.list Jsont.json) ~enc:(fun r -> r.matches)
+  |> Jsont.Object.mem "starterPacksWithMembership" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs_with_membership)
   |> Jsont.Object.finish
 
       end
-      module VerifyPhone = struct
-type input = {
-  code : string;
-  phone : string;
+      module GetActorStarterPacks = struct
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ code phone -> { code; phone })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.verifyPhone#input" ~enc:(fun _ -> "app.bsky.contact.verifyPhone#input")
-  |> Jsont.Object.mem "code" Jsont.string ~enc:(fun r -> r.code)
-  |> Jsont.Object.mem "phone" Jsont.string ~enc:(fun r -> r.phone)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor cursor limit -> {
+      actor;
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
-  token : string;
+  cursor : string option;
+  starter_packs : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ token -> { token })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.verifyPhone#output" ~enc:(fun _ -> "app.bsky.contact.verifyPhone#output")
-  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
+    (fun _typ cursor starter_packs -> { cursor; starter_packs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getActorStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.getActorStarterPacks#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
       end
-      module RemoveData = struct
-type input = unit
+      module List = struct
+type main = {
+  avatar : Atp.Blob_ref.t option;
+  created_at : string;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  name : string;
+  purpose : Jsont.json;
+}
 
-let input_jsont = Jsont.ignore
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ avatar created_at description description_facets labels name purpose -> { avatar; created_at; description; description_facets; labels; name; purpose })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.list" ~enc:(fun _ -> "app.bsky.graph.list")
+  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
+  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
+  |> Jsont.Object.finish
 
-type output = unit
+      end
+      module SearchStarterPacks = struct
+type params = {
+  cursor : string option;
+  limit : int option;
+  q : string;
+}
 
-let output_jsont = Jsont.ignore
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit q -> {
+      cursor;
+      limit;
+      q;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.mem "q" Jsont.string
+       ~enc:(fun r -> r.q)
+  |> Jsont.Object.finish
 
-      end
-      module Defs = struct
-type sync_status = {
-  matches_count : int;
-  synced_at : string;
+type output = {
+  cursor : string option;
+  starter_packs : Jsont.json list;
 }
 
-let sync_status_jsont =
-  Jsont.Object.map ~kind:"Sync_status"
-    (fun _typ matches_count synced_at -> { matches_count; synced_at })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#syncStatus" ~enc:(fun _ -> "app.bsky.contact.defs#syncStatus")
-  |> Jsont.Object.mem "matchesCount" Jsont.int ~enc:(fun r -> r.matches_count)
-  |> Jsont.Object.mem "syncedAt" Jsont.string ~enc:(fun r -> r.synced_at)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor starter_packs -> { cursor; starter_packs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.searchStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.searchStarterPacks#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
-type notification = {
-  from : string;
-  to_ : string;
+      end
+      module GetList = struct
+type params = {
+  cursor : string option;
+  limit : int option;
+  list_ : string;
 }
 
-let notification_jsont =
-  Jsont.Object.map ~kind:"Notification"
-    (fun _typ from to_ -> { from; to_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#notification" ~enc:(fun _ -> "app.bsky.contact.defs#notification")
-  |> Jsont.Object.mem "from" Jsont.string ~enc:(fun r -> r.from)
-  |> Jsont.Object.mem "to" Jsont.string ~enc:(fun r -> r.to_)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit list_ -> {
+      cursor;
+      limit;
+      list_;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.mem "list" Jsont.string
+       ~enc:(fun r -> r.list_)
   |> Jsont.Object.finish
 
-type match_and_contact_index = {
-  contact_index : int;
-  match_ : Jsont.json;
+type output = {
+  cursor : string option;
+  items : Jsont.json list;
+  list_ : Jsont.json;
 }
 
-let match_and_contact_index_jsont =
-  Jsont.Object.map ~kind:"Match_and_contact_index"
-    (fun _typ contact_index match_ -> { contact_index; match_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#matchAndContactIndex" ~enc:(fun _ -> "app.bsky.contact.defs#matchAndContactIndex")
-  |> Jsont.Object.mem "contactIndex" Jsont.int ~enc:(fun r -> r.contact_index)
-  |> Jsont.Object.mem "match" Jsont.json ~enc:(fun r -> r.match_)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor items list_ -> { cursor; items; list_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getList#output" ~enc:(fun _ -> "app.bsky.graph.getList#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "items" (Jsont.list Jsont.json) ~enc:(fun r -> r.items)
+  |> Jsont.Object.mem "list" Jsont.json ~enc:(fun r -> r.list_)
   |> Jsont.Object.finish
 
       end
-      module DismissMatch = struct
-type input = {
-  subject : string;
+      module GetListBlocks = struct
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ subject -> { subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.dismissMatch#input" ~enc:(fun _ -> "app.bsky.contact.dismissMatch#input")
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit -> {
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-type output = unit
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
+}
 
-let output_jsont = Jsont.ignore
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor lists -> { cursor; lists })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListBlocks#output" ~enc:(fun _ -> "app.bsky.graph.getListBlocks#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
+  |> Jsont.Object.finish
 
       end
-      module GetSyncStatus = struct
-type params = unit
+      module GetStarterPack = struct
+type params = {
+  starter_pack : string;
+}
 
-let params_jsont = Jsont.ignore
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun starter_pack -> {
+      starter_pack;
+    })
+  |> Jsont.Object.mem "starterPack" Jsont.string
+       ~enc:(fun r -> r.starter_pack)
+  |> Jsont.Object.finish
 
 type output = {
-  sync_status : Defs.sync_status option;
+  starter_pack : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ sync_status -> { sync_status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.getSyncStatus#output" ~enc:(fun _ -> "app.bsky.contact.getSyncStatus#output")
-  |> Jsont.Object.opt_mem "syncStatus" Defs.sync_status_jsont ~enc:(fun r -> r.sync_status)
+    (fun _typ starter_pack -> { starter_pack })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPack#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPack#output")
+  |> Jsont.Object.mem "starterPack" Jsont.json ~enc:(fun r -> r.starter_pack)
   |> Jsont.Object.finish
 
       end
-      module ImportContacts = struct
-type input = {
-  contacts : string list;
-  token : string;
+      module GetListsWithMembership = struct
+type list_with_membership = {
+  list_ : Jsont.json;
+  list_item : Jsont.json option;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ contacts token -> { contacts; token })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.importContacts#input" ~enc:(fun _ -> "app.bsky.contact.importContacts#input")
-  |> Jsont.Object.mem "contacts" (Jsont.list Jsont.string) ~enc:(fun r -> r.contacts)
-  |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
+let list_with_membership_jsont =
+  Jsont.Object.map ~kind:"List_with_membership"
+    (fun _typ list_ list_item -> { list_; list_item })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListsWithMembership#listWithMembership" ~enc:(fun _ -> "app.bsky.graph.getListsWithMembership#listWithMembership")
+  |> Jsont.Object.mem "list" Jsont.json ~enc:(fun r -> r.list_)
+  |> Jsont.Object.opt_mem "listItem" Jsont.json ~enc:(fun r -> r.list_item)
+  |> Jsont.Object.finish
+
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
+  purposes : string list option;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor cursor limit purposes -> {
+      actor;
+      cursor;
+      limit;
+      purposes;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.purposes)
   |> Jsont.Object.finish
 
 type output = {
-  matches_and_contact_indexes : Defs.match_and_contact_index list;
+  cursor : string option;
+  lists_with_membership : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ matches_and_contact_indexes -> { matches_and_contact_indexes })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.importContacts#output" ~enc:(fun _ -> "app.bsky.contact.importContacts#output")
-  |> Jsont.Object.mem "matchesAndContactIndexes" (Jsont.list Defs.match_and_contact_index_jsont) ~enc:(fun r -> r.matches_and_contact_indexes)
+    (fun _typ cursor lists_with_membership -> { cursor; lists_with_membership })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListsWithMembership#output" ~enc:(fun _ -> "app.bsky.graph.getListsWithMembership#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "listsWithMembership" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists_with_membership)
   |> Jsont.Object.finish
 
       end
-    end
-    module Feed = struct
-      module Repost = struct
-type main = {
-  created_at : string;
-  subject : Com.Atproto.Repo.StrongRef.main;
-  via : Com.Atproto.Repo.StrongRef.main option;
+      module GetListMutes = struct
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject via -> { created_at; subject; via })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.repost" ~enc:(fun _ -> "app.bsky.feed.repost")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
-  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit -> {
+      cursor;
+      limit;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
-      end
-      module DescribeFeedGenerator = struct
-type links = {
-  privacy_policy : string option;
-  terms_of_service : string option;
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
 }
 
-let links_jsont =
-  Jsont.Object.map ~kind:"Links"
-    (fun _typ privacy_policy terms_of_service -> { privacy_policy; terms_of_service })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#links" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#links")
-  |> Jsont.Object.opt_mem "privacyPolicy" Jsont.string ~enc:(fun r -> r.privacy_policy)
-  |> Jsont.Object.opt_mem "termsOfService" Jsont.string ~enc:(fun r -> r.terms_of_service)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor lists -> { cursor; lists })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListMutes#output" ~enc:(fun _ -> "app.bsky.graph.getListMutes#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
   |> Jsont.Object.finish
 
-type feed = {
-  uri : string;
+      end
+      module GetStarterPacks = struct
+type params = {
+  uris : string list;
 }
 
-let feed_jsont =
-  Jsont.Object.map ~kind:"Feed"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#feed" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#feed")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun uris -> {
+      uris;
+    })
+  |> Jsont.Object.mem "uris" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.uris)
   |> Jsont.Object.finish
 
 type output = {
-  did : string;
-  feeds : Jsont.json list;
-  links : Jsont.json option;
+  starter_packs : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ did feeds links -> { did; feeds; links })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#output" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#output")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.opt_mem "links" Jsont.json ~enc:(fun r -> r.links)
+    (fun _typ starter_packs -> { starter_packs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPacks#output")
+  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
       end
-      module Threadgate = struct
-type mention_rule = unit
+      module GetLists = struct
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
+  purposes : string list option;
+}
 
-let mention_rule_jsont = Jsont.ignore
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun actor cursor limit purposes -> {
+      actor;
+      cursor;
+      limit;
+      purposes;
+    })
+  |> Jsont.Object.mem "actor" Jsont.string
+       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.purposes)
+  |> Jsont.Object.finish
 
-type list_rule = {
-  list_ : string;
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
 }
 
-let list_rule_jsont =
-  Jsont.Object.map ~kind:"List_rule"
-    (fun _typ list_ -> { list_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.threadgate#listRule" ~enc:(fun _ -> "app.bsky.feed.threadgate#listRule")
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ cursor lists -> { cursor; lists })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getLists#output" ~enc:(fun _ -> "app.bsky.graph.getLists#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
   |> Jsont.Object.finish
 
-type following_rule = unit
+      end
+    end
+    module Feed = struct
+      module Post = struct
+type text_slice = {
+  end_ : int;
+  start : int;
+}
 
-let following_rule_jsont = Jsont.ignore
+let text_slice_jsont =
+  Jsont.Object.map ~kind:"Text_slice"
+    (fun _typ end_ start -> { end_; start })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#textSlice" ~enc:(fun _ -> "app.bsky.feed.post#textSlice")
+  |> Jsont.Object.mem "end" Jsont.int ~enc:(fun r -> r.end_)
+  |> Jsont.Object.mem "start" Jsont.int ~enc:(fun r -> r.start)
+  |> Jsont.Object.finish
 
-type follower_rule = unit
+type reply_ref = {
+  parent : Com.Atproto.Repo.StrongRef.main;
+  root : Com.Atproto.Repo.StrongRef.main;
+}
 
-let follower_rule_jsont = Jsont.ignore
+let reply_ref_jsont =
+  Jsont.Object.map ~kind:"Reply_ref"
+    (fun _typ parent root -> { parent; root })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#replyRef" ~enc:(fun _ -> "app.bsky.feed.post#replyRef")
+  |> Jsont.Object.mem "parent" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.parent)
+  |> Jsont.Object.mem "root" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.root)
+  |> Jsont.Object.finish
 
-type main = {
-  allow : Jsont.json list option;
-  created_at : string;
-  hidden_replies : string list option;
-  post : string;
+type entity = {
+  index : Jsont.json;
+  type_ : string;
+  value : string;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ allow created_at hidden_replies post -> { allow; created_at; hidden_replies; post })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.threadgate" ~enc:(fun _ -> "app.bsky.feed.threadgate")
-  |> Jsont.Object.opt_mem "allow" (Jsont.list Jsont.json) ~enc:(fun r -> r.allow)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "hiddenReplies" (Jsont.list Jsont.string) ~enc:(fun r -> r.hidden_replies)
-  |> Jsont.Object.mem "post" Jsont.string ~enc:(fun r -> r.post)
+let entity_jsont =
+  Jsont.Object.map ~kind:"Entity"
+    (fun _typ index type_ value -> { index; type_; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#entity" ~enc:(fun _ -> "app.bsky.feed.post#entity")
+  |> Jsont.Object.mem "index" Jsont.json ~enc:(fun r -> r.index)
+  |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.type_)
+  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
-      end
-      module Like = struct
 type main = {
   created_at : string;
-  subject : Com.Atproto.Repo.StrongRef.main;
-  via : Com.Atproto.Repo.StrongRef.main option;
+  embed : Jsont.json option;
+  entities : Jsont.json list option;
+  facets : Richtext.Facet.main list option;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  langs : string list option;
+  reply : Jsont.json option;
+  tags : string list option;
+  text : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject via -> { created_at; subject; via })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.like" ~enc:(fun _ -> "app.bsky.feed.like")
+    (fun _typ created_at embed entities facets labels langs reply tags text -> { created_at; embed; entities; facets; labels; langs; reply; tags; text })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post" ~enc:(fun _ -> "app.bsky.feed.post")
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
-  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
+  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
+  |> Jsont.Object.opt_mem "entities" (Jsont.list Jsont.json) ~enc:(fun r -> r.entities)
+  |> Jsont.Object.opt_mem "facets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.facets)
+  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> Jsont.Object.opt_mem "langs" (Jsont.list Jsont.string) ~enc:(fun r -> r.langs)
+  |> Jsont.Object.opt_mem "reply" Jsont.json ~enc:(fun r -> r.reply)
+  |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+  |> Jsont.Object.mem "text" Jsont.string ~enc:(fun r -> r.text)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
+      module Postgate = struct
+type disable_rule = unit
+
+let disable_rule_jsont = Jsont.ignore
+
+type main = {
+  created_at : string;
+  detached_embedding_uris : string list option;
+  embedding_rules : Jsont.json list option;
+  post : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at detached_embedding_uris embedding_rules post -> { created_at; detached_embedding_uris; embedding_rules; post })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.postgate" ~enc:(fun _ -> "app.bsky.feed.postgate")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "detachedEmbeddingUris" (Jsont.list Jsont.string) ~enc:(fun r -> r.detached_embedding_uris)
+  |> Jsont.Object.opt_mem "embeddingRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.embedding_rules)
+  |> Jsont.Object.mem "post" Jsont.string ~enc:(fun r -> r.post)
+  |> Jsont.Object.finish
+
+      end
       module GetRepostedBy = struct
 type params = {
   cid : string option;
···
   |> Jsont.Object.finish
 
       end
-      module Generator = struct
-type main = {
-  accepts_interactions : bool option;
-  avatar : Atp.Blob_ref.t option;
-  content_mode : string option;
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
+      module DescribeFeedGenerator = struct
+type links = {
+  privacy_policy : string option;
+  terms_of_service : string option;
+}
+
+let links_jsont =
+  Jsont.Object.map ~kind:"Links"
+    (fun _typ privacy_policy terms_of_service -> { privacy_policy; terms_of_service })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#links" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#links")
+  |> Jsont.Object.opt_mem "privacyPolicy" Jsont.string ~enc:(fun r -> r.privacy_policy)
+  |> Jsont.Object.opt_mem "termsOfService" Jsont.string ~enc:(fun r -> r.terms_of_service)
+  |> Jsont.Object.finish
+
+type feed = {
+  uri : string;
+}
+
+let feed_jsont =
+  Jsont.Object.map ~kind:"Feed"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#feed" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#feed")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type output = {
   did : string;
-  display_name : string;
-  labels : Com.Atproto.Label.Defs.self_labels option;
+  feeds : Jsont.json list;
+  links : Jsont.json option;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ accepts_interactions avatar content_mode created_at description description_facets did display_name labels -> { accepts_interactions; avatar; content_mode; created_at; description; description_facets; did; display_name; labels })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.generator" ~enc:(fun _ -> "app.bsky.feed.generator")
-  |> Jsont.Object.opt_mem "acceptsInteractions" Jsont.bool ~enc:(fun r -> r.accepts_interactions)
-  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "contentMode" Jsont.string ~enc:(fun r -> r.content_mode)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ did feeds links -> { did; feeds; links })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.describeFeedGenerator#output" ~enc:(fun _ -> "app.bsky.feed.describeFeedGenerator#output")
   |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
+  |> Jsont.Object.opt_mem "links" Jsont.json ~enc:(fun r -> r.links)
   |> Jsont.Object.finish
 
       end
-      module Postgate = struct
-type disable_rule = unit
+      module Threadgate = struct
+type mention_rule = unit
 
-let disable_rule_jsont = Jsont.ignore
+let mention_rule_jsont = Jsont.ignore
+
+type list_rule = {
+  list_ : string;
+}
+
+let list_rule_jsont =
+  Jsont.Object.map ~kind:"List_rule"
+    (fun _typ list_ -> { list_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.threadgate#listRule" ~enc:(fun _ -> "app.bsky.feed.threadgate#listRule")
+  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
+  |> Jsont.Object.finish
+
+type following_rule = unit
+
+let following_rule_jsont = Jsont.ignore
+
+type follower_rule = unit
+
+let follower_rule_jsont = Jsont.ignore
 
 type main = {
+  allow : Jsont.json list option;
   created_at : string;
-  detached_embedding_uris : string list option;
-  embedding_rules : Jsont.json list option;
+  hidden_replies : string list option;
   post : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at detached_embedding_uris embedding_rules post -> { created_at; detached_embedding_uris; embedding_rules; post })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.postgate" ~enc:(fun _ -> "app.bsky.feed.postgate")
+    (fun _typ allow created_at hidden_replies post -> { allow; created_at; hidden_replies; post })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.threadgate" ~enc:(fun _ -> "app.bsky.feed.threadgate")
+  |> Jsont.Object.opt_mem "allow" (Jsont.list Jsont.json) ~enc:(fun r -> r.allow)
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "detachedEmbeddingUris" (Jsont.list Jsont.string) ~enc:(fun r -> r.detached_embedding_uris)
-  |> Jsont.Object.opt_mem "embeddingRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.embedding_rules)
+  |> Jsont.Object.opt_mem "hiddenReplies" (Jsont.list Jsont.string) ~enc:(fun r -> r.hidden_replies)
   |> Jsont.Object.mem "post" Jsont.string ~enc:(fun r -> r.post)
+  |> Jsont.Object.finish
+
+      end
+      module Like = struct
+type main = {
+  created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
+  via : Com.Atproto.Repo.StrongRef.main option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject via -> { created_at; subject; via })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.like" ~enc:(fun _ -> "app.bsky.feed.like")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
+  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module Post = struct
-type text_slice = {
-  end_ : int;
-  start : int;
-}
-
-let text_slice_jsont =
-  Jsont.Object.map ~kind:"Text_slice"
-    (fun _typ end_ start -> { end_; start })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#textSlice" ~enc:(fun _ -> "app.bsky.feed.post#textSlice")
-  |> Jsont.Object.mem "end" Jsont.int ~enc:(fun r -> r.end_)
-  |> Jsont.Object.mem "start" Jsont.int ~enc:(fun r -> r.start)
-  |> Jsont.Object.finish
-
-type reply_ref = {
-  parent : Com.Atproto.Repo.StrongRef.main;
-  root : Com.Atproto.Repo.StrongRef.main;
-}
-
-let reply_ref_jsont =
-  Jsont.Object.map ~kind:"Reply_ref"
-    (fun _typ parent root -> { parent; root })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#replyRef" ~enc:(fun _ -> "app.bsky.feed.post#replyRef")
-  |> Jsont.Object.mem "parent" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.parent)
-  |> Jsont.Object.mem "root" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.root)
-  |> Jsont.Object.finish
-
-type entity = {
-  index : Jsont.json;
-  type_ : string;
-  value : string;
+      module Repost = struct
+type main = {
+  created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
+  via : Com.Atproto.Repo.StrongRef.main option;
 }
 
-let entity_jsont =
-  Jsont.Object.map ~kind:"Entity"
-    (fun _typ index type_ value -> { index; type_; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#entity" ~enc:(fun _ -> "app.bsky.feed.post#entity")
-  |> Jsont.Object.mem "index" Jsont.json ~enc:(fun r -> r.index)
-  |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.type_)
-  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject via -> { created_at; subject; via })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.repost" ~enc:(fun _ -> "app.bsky.feed.repost")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
+  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
   |> Jsont.Object.finish
 
+      end
+      module Generator = struct
 type main = {
+  accepts_interactions : bool option;
+  avatar : Atp.Blob_ref.t option;
+  content_mode : string option;
   created_at : string;
-  embed : Jsont.json option;
-  entities : Jsont.json list option;
-  facets : Richtext.Facet.main list option;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  did : string;
+  display_name : string;
   labels : Com.Atproto.Label.Defs.self_labels option;
-  langs : string list option;
-  reply : Jsont.json option;
-  tags : string list option;
-  text : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at embed entities facets labels langs reply tags text -> { created_at; embed; entities; facets; labels; langs; reply; tags; text })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post" ~enc:(fun _ -> "app.bsky.feed.post")
+    (fun _typ accepts_interactions avatar content_mode created_at description description_facets did display_name labels -> { accepts_interactions; avatar; content_mode; created_at; description; description_facets; did; display_name; labels })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.generator" ~enc:(fun _ -> "app.bsky.feed.generator")
+  |> Jsont.Object.opt_mem "acceptsInteractions" Jsont.bool ~enc:(fun r -> r.accepts_interactions)
+  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.opt_mem "contentMode" Jsont.string ~enc:(fun r -> r.content_mode)
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
-  |> Jsont.Object.opt_mem "entities" (Jsont.list Jsont.json) ~enc:(fun r -> r.entities)
-  |> Jsont.Object.opt_mem "facets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.facets)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
   |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "langs" (Jsont.list Jsont.string) ~enc:(fun r -> r.langs)
-  |> Jsont.Object.opt_mem "reply" Jsont.json ~enc:(fun r -> r.reply)
-  |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
-  |> Jsont.Object.mem "text" Jsont.string ~enc:(fun r -> r.text)
   |> Jsont.Object.finish
 
       end
-      module GetPosts = struct
+      module GetPostThread = struct
 type params = {
-  uris : string list;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun uris -> {
-      uris;
-    })
-  |> Jsont.Object.mem "uris" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.uris)
-  |> Jsont.Object.finish
-
-type output = {
-  posts : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ posts -> { posts })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getPosts#output" ~enc:(fun _ -> "app.bsky.feed.getPosts#output")
-  |> Jsont.Object.mem "posts" (Jsont.list Jsont.json) ~enc:(fun r -> r.posts)
-  |> Jsont.Object.finish
-
-      end
-      module GetQuotes = struct
-type params = {
-  cid : string option;
-  cursor : string option;
-  limit : int option;
+  depth : int option;
+  parent_height : int option;
   uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cid cursor limit uri -> {
-      cid;
-      cursor;
-      limit;
+    (fun depth parent_height uri -> {
+      depth;
+      parent_height;
       uri;
     })
-  |> Jsont.Object.opt_mem "cid" Jsont.string
-       ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "depth" Jsont.int
+       ~enc:(fun r -> r.depth)
+  |> Jsont.Object.opt_mem "parentHeight" Jsont.int
+       ~enc:(fun r -> r.parent_height)
   |> Jsont.Object.mem "uri" Jsont.string
        ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type output = {
-  cid : string option;
-  cursor : string option;
-  posts : Jsont.json list;
-  uri : string;
+  thread : Jsont.json;
+  threadgate : Jsont.json option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cid cursor posts uri -> { cid; cursor; posts; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getQuotes#output" ~enc:(fun _ -> "app.bsky.feed.getQuotes#output")
-  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "posts" (Jsont.list Jsont.json) ~enc:(fun r -> r.posts)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+    (fun _typ thread threadgate -> { thread; threadgate })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getPostThread#output" ~enc:(fun _ -> "app.bsky.feed.getPostThread#output")
+  |> Jsont.Object.mem "thread" Jsont.json ~enc:(fun r -> r.thread)
+  |> Jsont.Object.opt_mem "threadgate" Jsont.json ~enc:(fun r -> r.threadgate)
   |> Jsont.Object.finish
 
       end
-      module GetAuthorFeed = struct
+      module GetFeed = struct
 type params = {
-  actor : string;
   cursor : string option;
-  filter : string option;
-  include_pins : bool option;
+  feed : string;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor filter include_pins limit -> {
-      actor;
+    (fun cursor feed limit -> {
       cursor;
-      filter;
-      include_pins;
+      feed;
       limit;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "filter" Jsont.string
-       ~enc:(fun r -> r.filter)
-  |> Jsont.Object.opt_mem "includePins" Jsont.bool
-       ~enc:(fun r -> r.include_pins)
+  |> Jsont.Object.mem "feed" Jsont.string
+       ~enc:(fun r -> r.feed)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
···
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
     (fun _typ cursor feed -> { cursor; feed })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getAuthorFeed#output" ~enc:(fun _ -> "app.bsky.feed.getAuthorFeed#output")
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeed#output" ~enc:(fun _ -> "app.bsky.feed.getFeed#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
   |> Jsont.Object.finish
 
       end
-      module GetTimeline = struct
+      module GetQuotes = struct
 type params = {
-  algorithm : string option;
+  cid : string option;
   cursor : string option;
   limit : int option;
+  uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun algorithm cursor limit -> {
-      algorithm;
+    (fun cid cursor limit uri -> {
+      cid;
       cursor;
       limit;
+      uri;
     })
-  |> Jsont.Object.opt_mem "algorithm" Jsont.string
-       ~enc:(fun r -> r.algorithm)
+  |> Jsont.Object.opt_mem "cid" Jsont.string
+       ~enc:(fun r -> r.cid)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
+  |> Jsont.Object.mem "uri" Jsont.string
+       ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type output = {
+  cid : string option;
   cursor : string option;
-  feed : Jsont.json list;
+  posts : Jsont.json list;
+  uri : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feed -> { cursor; feed })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getTimeline#output" ~enc:(fun _ -> "app.bsky.feed.getTimeline#output")
+    (fun _typ cid cursor posts uri -> { cid; cursor; posts; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getQuotes#output" ~enc:(fun _ -> "app.bsky.feed.getQuotes#output")
+  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
+  |> Jsont.Object.mem "posts" (Jsont.list Jsont.json) ~enc:(fun r -> r.posts)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module GetSuggestedFeeds = struct
-type params = {
-  cursor : string option;
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
-      limit;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  feeds : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feeds -> { cursor; feeds })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getSuggestedFeeds#output" ~enc:(fun _ -> "app.bsky.feed.getSuggestedFeeds#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.finish
-
-      end
       module GetActorLikes = struct
 type params = {
   actor : string;
···
   |> Jsont.Object.finish
 
       end
-      module GetActorFeeds = struct
+      module GetFeedSkeleton = struct
 type params = {
-  actor : string;
   cursor : string option;
+  feed : string;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit -> {
-      actor;
+    (fun cursor feed limit -> {
       cursor;
+      feed;
       limit;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "feed" Jsont.string
+       ~enc:(fun r -> r.feed)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
-  feeds : Jsont.json list;
+  feed : Jsont.json list;
+  req_id : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feeds -> { cursor; feeds })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getActorFeeds#output" ~enc:(fun _ -> "app.bsky.feed.getActorFeeds#output")
+    (fun _typ cursor feed req_id -> { cursor; feed; req_id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeedSkeleton#output" ~enc:(fun _ -> "app.bsky.feed.getFeedSkeleton#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
+  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
+  |> Jsont.Object.opt_mem "reqId" Jsont.string ~enc:(fun r -> r.req_id)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module GetPostThread = struct
-type params = {
-  depth : int option;
-  parent_height : int option;
-  uri : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun depth parent_height uri -> {
-      depth;
-      parent_height;
-      uri;
-    })
-  |> Jsont.Object.opt_mem "depth" Jsont.int
-       ~enc:(fun r -> r.depth)
-  |> Jsont.Object.opt_mem "parentHeight" Jsont.int
-       ~enc:(fun r -> r.parent_height)
-  |> Jsont.Object.mem "uri" Jsont.string
-       ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type output = {
-  thread : Jsont.json;
-  threadgate : Jsont.json option;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ thread threadgate -> { thread; threadgate })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getPostThread#output" ~enc:(fun _ -> "app.bsky.feed.getPostThread#output")
-  |> Jsont.Object.mem "thread" Jsont.json ~enc:(fun r -> r.thread)
-  |> Jsont.Object.opt_mem "threadgate" Jsont.json ~enc:(fun r -> r.threadgate)
-  |> Jsont.Object.finish
-
-      end
-      module GetFeedSkeleton = struct
-type params = {
-  cursor : string option;
-  feed : string;
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor feed limit -> {
-      cursor;
-      feed;
-      limit;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feed" Jsont.string
-       ~enc:(fun r -> r.feed)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  feed : Jsont.json list;
-  req_id : string option;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feed req_id -> { cursor; feed; req_id })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeedSkeleton#output" ~enc:(fun _ -> "app.bsky.feed.getFeedSkeleton#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
-  |> Jsont.Object.opt_mem "reqId" Jsont.string ~enc:(fun r -> r.req_id)
-  |> Jsont.Object.finish
-
-      end
-      module GetFeed = struct
-type params = {
-  cursor : string option;
-  feed : string;
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor feed limit -> {
-      cursor;
-      feed;
-      limit;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feed" Jsont.string
-       ~enc:(fun r -> r.feed)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  feed : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feed -> { cursor; feed })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeed#output" ~enc:(fun _ -> "app.bsky.feed.getFeed#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
-  |> Jsont.Object.finish
-
-      end
       module GetFeedGenerators = struct
 type params = {
   feeds : string list;
···
 let output_jsont = Jsont.ignore
 
       end
-      module GetFeedGenerator = struct
-type params = {
-  feed : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun feed -> {
-      feed;
-    })
-  |> Jsont.Object.mem "feed" Jsont.string
-       ~enc:(fun r -> r.feed)
-  |> Jsont.Object.finish
-
-type output = {
-  is_online : bool;
-  is_valid : bool;
-  view : Jsont.json;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ is_online is_valid view -> { is_online; is_valid; view })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeedGenerator#output" ~enc:(fun _ -> "app.bsky.feed.getFeedGenerator#output")
-  |> Jsont.Object.mem "isOnline" Jsont.bool ~enc:(fun r -> r.is_online)
-  |> Jsont.Object.mem "isValid" Jsont.bool ~enc:(fun r -> r.is_valid)
-  |> Jsont.Object.mem "view" Jsont.json ~enc:(fun r -> r.view)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Graph = struct
-      module Defs = struct
-type starter_pack_view_basic = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  joined_all_time_count : int option;
-  joined_week_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  record : Jsont.json;
-  uri : string;
-}
-
-let starter_pack_view_basic_jsont =
-  Jsont.Object.map ~kind:"Starter_pack_view_basic"
-    (fun _typ cid creator indexed_at joined_all_time_count joined_week_count labels list_item_count record uri -> { cid; creator; indexed_at; joined_all_time_count; joined_week_count; labels; list_item_count; record; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#starterPackViewBasic" ~enc:(fun _ -> "app.bsky.graph.defs#starterPackViewBasic")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "joinedAllTimeCount" Jsont.int ~enc:(fun r -> r.joined_all_time_count)
-  |> Jsont.Object.opt_mem "joinedWeekCount" Jsont.int ~enc:(fun r -> r.joined_week_count)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type relationship = {
-  blocked_by : string option;
-  blocked_by_list : string option;
-  blocking : string option;
-  blocking_by_list : string option;
-  did : string;
-  followed_by : string option;
-  following : string option;
-}
-
-let relationship_jsont =
-  Jsont.Object.map ~kind:"Relationship"
-    (fun _typ blocked_by blocked_by_list blocking blocking_by_list did followed_by following -> { blocked_by; blocked_by_list; blocking; blocking_by_list; did; followed_by; following })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#relationship" ~enc:(fun _ -> "app.bsky.graph.defs#relationship")
-  |> Jsont.Object.opt_mem "blockedBy" Jsont.string ~enc:(fun r -> r.blocked_by)
-  |> Jsont.Object.opt_mem "blockedByList" Jsont.string ~enc:(fun r -> r.blocked_by_list)
-  |> Jsont.Object.opt_mem "blocking" Jsont.string ~enc:(fun r -> r.blocking)
-  |> Jsont.Object.opt_mem "blockingByList" Jsont.string ~enc:(fun r -> r.blocking_by_list)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.opt_mem "followedBy" Jsont.string ~enc:(fun r -> r.followed_by)
-  |> Jsont.Object.opt_mem "following" Jsont.string ~enc:(fun r -> r.following)
-  |> Jsont.Object.finish
-
-type referencelist = string
-let referencelist_jsont = Jsont.string
-
-type not_found_actor = {
-  actor : string;
-  not_found : bool;
-}
-
-let not_found_actor_jsont =
-  Jsont.Object.map ~kind:"Not_found_actor"
-    (fun _typ actor not_found -> { actor; not_found })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#notFoundActor" ~enc:(fun _ -> "app.bsky.graph.defs#notFoundActor")
-  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
-  |> Jsont.Object.mem "notFound" Jsont.bool ~enc:(fun r -> r.not_found)
-  |> Jsont.Object.finish
-
-type modlist = string
-let modlist_jsont = Jsont.string
-
-type list_viewer_state = {
-  blocked : string option;
-  muted : bool option;
-}
-
-let list_viewer_state_jsont =
-  Jsont.Object.map ~kind:"List_viewer_state"
-    (fun _typ blocked muted -> { blocked; muted })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listViewerState" ~enc:(fun _ -> "app.bsky.graph.defs#listViewerState")
-  |> Jsont.Object.opt_mem "blocked" Jsont.string ~enc:(fun r -> r.blocked)
-  |> Jsont.Object.opt_mem "muted" Jsont.bool ~enc:(fun r -> r.muted)
-  |> Jsont.Object.finish
-
-type list_purpose = string
-let list_purpose_jsont = Jsont.string
-
-type list_item_view = {
-  subject : Jsont.json;
-  uri : string;
-}
-
-let list_item_view_jsont =
-  Jsont.Object.map ~kind:"List_item_view"
-    (fun _typ subject uri -> { subject; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listItemView" ~enc:(fun _ -> "app.bsky.graph.defs#listItemView")
-  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type curatelist = string
-let curatelist_jsont = Jsont.string
-
-type list_view_basic = {
-  avatar : string option;
-  cid : string;
-  indexed_at : string option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  name : string;
-  purpose : Jsont.json;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-let list_view_basic_jsont =
-  Jsont.Object.map ~kind:"List_view_basic"
-    (fun _typ avatar cid indexed_at labels list_item_count name purpose uri viewer -> { avatar; cid; indexed_at; labels; list_item_count; name; purpose; uri; viewer })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listViewBasic" ~enc:(fun _ -> "app.bsky.graph.defs#listViewBasic")
-  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type list_view = {
-  avatar : string option;
-  cid : string;
-  creator : Jsont.json;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  name : string;
-  purpose : Jsont.json;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-let list_view_jsont =
-  Jsont.Object.map ~kind:"List_view"
-    (fun _typ avatar cid creator description description_facets indexed_at labels list_item_count name purpose uri viewer -> { avatar; cid; creator; description; description_facets; indexed_at; labels; list_item_count; name; purpose; uri; viewer })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listView" ~enc:(fun _ -> "app.bsky.graph.defs#listView")
-  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type starter_pack_view = {
-  cid : string;
-  creator : Jsont.json;
-  feeds : Jsont.json list option;
-  indexed_at : string;
-  joined_all_time_count : int option;
-  joined_week_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_ : Jsont.json option;
-  list_items_sample : Jsont.json list option;
-  record : Jsont.json;
-  uri : string;
-}
-
-let starter_pack_view_jsont =
-  Jsont.Object.map ~kind:"Starter_pack_view"
-    (fun _typ cid creator feeds indexed_at joined_all_time_count joined_week_count labels list_ list_items_sample record uri -> { cid; creator; feeds; indexed_at; joined_all_time_count; joined_week_count; labels; list_; list_items_sample; record; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#starterPackView" ~enc:(fun _ -> "app.bsky.graph.defs#starterPackView")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "joinedAllTimeCount" Jsont.int ~enc:(fun r -> r.joined_all_time_count)
-  |> Jsont.Object.opt_mem "joinedWeekCount" Jsont.int ~enc:(fun r -> r.joined_week_count)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "list" Jsont.json ~enc:(fun r -> r.list_)
-  |> Jsont.Object.opt_mem "listItemsSample" (Jsont.list Jsont.json) ~enc:(fun r -> r.list_items_sample)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-      end
-      module UnmuteActor = struct
-type input = {
-  actor : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ actor -> { actor })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteActor#input" ~enc:(fun _ -> "app.bsky.graph.unmuteActor#input")
-  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
-  |> Jsont.Object.finish
-
-      end
-      module Listitem = struct
-type main = {
-  created_at : string;
-  list_ : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at list_ subject -> { created_at; list_; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.listitem" ~enc:(fun _ -> "app.bsky.graph.listitem")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module GetSuggestedFollowsByActor = struct
-type params = {
-  actor : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun actor -> {
-      actor;
-    })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
-  |> Jsont.Object.finish
-
-type output = {
-  is_fallback : bool option;
-  rec_id : int option;
-  suggestions : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ is_fallback rec_id suggestions -> { is_fallback; rec_id; suggestions })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getSuggestedFollowsByActor#output" ~enc:(fun _ -> "app.bsky.graph.getSuggestedFollowsByActor#output")
-  |> Jsont.Object.opt_mem "isFallback" Jsont.bool ~enc:(fun r -> r.is_fallback)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
-  |> Jsont.Object.mem "suggestions" (Jsont.list Jsont.json) ~enc:(fun r -> r.suggestions)
-  |> Jsont.Object.finish
-
-      end
-      module MuteActorList = struct
-type input = {
-  list_ : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ list_ -> { list_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteActorList#input" ~enc:(fun _ -> "app.bsky.graph.muteActorList#input")
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
-  |> Jsont.Object.finish
-
-      end
-      module GetFollowers = struct
+      module GetAuthorFeed = struct
 type params = {
   actor : string;
   cursor : string option;
+  filter : string option;
+  include_pins : bool option;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit -> {
+    (fun actor cursor filter include_pins limit -> {
       actor;
       cursor;
+      filter;
+      include_pins;
       limit;
     })
   |> Jsont.Object.mem "actor" Jsont.string
        ~enc:(fun r -> r.actor)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "filter" Jsont.string
+       ~enc:(fun r -> r.filter)
+  |> Jsont.Object.opt_mem "includePins" Jsont.bool
+       ~enc:(fun r -> r.include_pins)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
-  followers : Jsont.json list;
-  subject : Jsont.json;
+  feed : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor followers subject -> { cursor; followers; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getFollowers#output" ~enc:(fun _ -> "app.bsky.graph.getFollowers#output")
+    (fun _typ cursor feed -> { cursor; feed })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getAuthorFeed#output" ~enc:(fun _ -> "app.bsky.feed.getAuthorFeed#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "followers" (Jsont.list Jsont.json) ~enc:(fun r -> r.followers)
-  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module MuteActor = struct
-type input = {
-  actor : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ actor -> { actor })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteActor#input" ~enc:(fun _ -> "app.bsky.graph.muteActor#input")
-  |> Jsont.Object.mem "actor" Jsont.string ~enc:(fun r -> r.actor)
-  |> Jsont.Object.finish
-
-      end
-      module UnmuteActorList = struct
-type input = {
-  list_ : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ list_ -> { list_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteActorList#input" ~enc:(fun _ -> "app.bsky.graph.unmuteActorList#input")
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
+  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
   |> Jsont.Object.finish
 
       end
-      module GetBlocks = struct
+      module GetFeedGenerator = struct
 type params = {
-  cursor : string option;
-  limit : int option;
+  feed : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
-      limit;
+    (fun feed -> {
+      feed;
     })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.mem "feed" Jsont.string
+       ~enc:(fun r -> r.feed)
   |> Jsont.Object.finish
 
 type output = {
-  blocks : Jsont.json list;
-  cursor : string option;
+  is_online : bool;
+  is_valid : bool;
+  view : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ blocks cursor -> { blocks; cursor })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getBlocks#output" ~enc:(fun _ -> "app.bsky.graph.getBlocks#output")
-  |> Jsont.Object.mem "blocks" (Jsont.list Jsont.json) ~enc:(fun r -> r.blocks)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+    (fun _typ is_online is_valid view -> { is_online; is_valid; view })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getFeedGenerator#output" ~enc:(fun _ -> "app.bsky.feed.getFeedGenerator#output")
+  |> Jsont.Object.mem "isOnline" Jsont.bool ~enc:(fun r -> r.is_online)
+  |> Jsont.Object.mem "isValid" Jsont.bool ~enc:(fun r -> r.is_valid)
+  |> Jsont.Object.mem "view" Jsont.json ~enc:(fun r -> r.view)
   |> Jsont.Object.finish
 
       end
-      module Listblock = struct
-type main = {
-  created_at : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject -> { created_at; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.listblock" ~enc:(fun _ -> "app.bsky.graph.listblock")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module MuteThread = struct
-type input = {
-  root : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ root -> { root })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.muteThread#input" ~enc:(fun _ -> "app.bsky.graph.muteThread#input")
-  |> Jsont.Object.mem "root" Jsont.string ~enc:(fun r -> r.root)
-  |> Jsont.Object.finish
-
-      end
-      module Follow = struct
-type main = {
-  created_at : string;
-  subject : string;
-  via : Com.Atproto.Repo.StrongRef.main option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject via -> { created_at; subject; via })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.follow" ~enc:(fun _ -> "app.bsky.graph.follow")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
-  |> Jsont.Object.finish
-
-      end
-      module Starterpack = struct
-type feed_item = {
-  uri : string;
-}
-
-let feed_item_jsont =
-  Jsont.Object.map ~kind:"Feed_item"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.starterpack#feedItem" ~enc:(fun _ -> "app.bsky.graph.starterpack#feedItem")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type main = {
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  feeds : Jsont.json list option;
-  list_ : string;
-  name : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at description description_facets feeds list_ name -> { created_at; description; description_facets; feeds; list_; name })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.starterpack" ~enc:(fun _ -> "app.bsky.graph.starterpack")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
-  |> Jsont.Object.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.finish
-
-      end
-      module GetFollows = struct
-type params = {
-  actor : string;
-  cursor : string option;
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit -> {
-      actor;
-      cursor;
-      limit;
-    })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  follows : Jsont.json list;
-  subject : Jsont.json;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor follows subject -> { cursor; follows; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getFollows#output" ~enc:(fun _ -> "app.bsky.graph.getFollows#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "follows" (Jsont.list Jsont.json) ~enc:(fun r -> r.follows)
-  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module Verification = struct
-type main = {
-  created_at : string;
-  display_name : string;
-  handle : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at display_name handle subject -> { created_at; display_name; handle; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.verification" ~enc:(fun _ -> "app.bsky.graph.verification")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module UnmuteThread = struct
-type input = {
-  root : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ root -> { root })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.unmuteThread#input" ~enc:(fun _ -> "app.bsky.graph.unmuteThread#input")
-  |> Jsont.Object.mem "root" Jsont.string ~enc:(fun r -> r.root)
-  |> Jsont.Object.finish
-
-      end
-      module GetMutes = struct
+      module GetSuggestedFeeds = struct
 type params = {
   cursor : string option;
   limit : int option;
···
 
 type output = {
   cursor : string option;
-  mutes : Jsont.json list;
+  feeds : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor mutes -> { cursor; mutes })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getMutes#output" ~enc:(fun _ -> "app.bsky.graph.getMutes#output")
+    (fun _typ cursor feeds -> { cursor; feeds })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getSuggestedFeeds#output" ~enc:(fun _ -> "app.bsky.feed.getSuggestedFeeds#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "mutes" (Jsont.list Jsont.json) ~enc:(fun r -> r.mutes)
+  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
   |> Jsont.Object.finish
 
       end
-      module GetKnownFollowers = struct
+      module GetActorFeeds = struct
 type params = {
   actor : string;
   cursor : string option;
···
 
 type output = {
   cursor : string option;
-  followers : Jsont.json list;
-  subject : Jsont.json;
+  feeds : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor followers subject -> { cursor; followers; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getKnownFollowers#output" ~enc:(fun _ -> "app.bsky.graph.getKnownFollowers#output")
+    (fun _typ cursor feeds -> { cursor; feeds })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getActorFeeds#output" ~enc:(fun _ -> "app.bsky.feed.getActorFeeds#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "followers" (Jsont.list Jsont.json) ~enc:(fun r -> r.followers)
-  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module Block = struct
-type main = {
-  created_at : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject -> { created_at; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.block" ~enc:(fun _ -> "app.bsky.graph.block")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
   |> Jsont.Object.finish
 
       end
-      module GetRelationships = struct
+      module GetPosts = struct
 type params = {
-  actor : string;
-  others : string list option;
+  uris : string list;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor others -> {
-      actor;
-      others;
+    (fun uris -> {
+      uris;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "others" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.others)
+  |> Jsont.Object.mem "uris" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.uris)
   |> Jsont.Object.finish
 
 type output = {
-  actor : string option;
-  relationships : Jsont.json list;
+  posts : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ actor relationships -> { actor; relationships })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getRelationships#output" ~enc:(fun _ -> "app.bsky.graph.getRelationships#output")
-  |> Jsont.Object.opt_mem "actor" Jsont.string ~enc:(fun r -> r.actor)
-  |> Jsont.Object.mem "relationships" (Jsont.list Jsont.json) ~enc:(fun r -> r.relationships)
+    (fun _typ posts -> { posts })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getPosts#output" ~enc:(fun _ -> "app.bsky.feed.getPosts#output")
+  |> Jsont.Object.mem "posts" (Jsont.list Jsont.json) ~enc:(fun r -> r.posts)
   |> Jsont.Object.finish
 
       end
-      module GetListsWithMembership = struct
-type list_with_membership = {
-  list_ : Jsont.json;
-  list_item : Jsont.json option;
-}
-
-let list_with_membership_jsont =
-  Jsont.Object.map ~kind:"List_with_membership"
-    (fun _typ list_ list_item -> { list_; list_item })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListsWithMembership#listWithMembership" ~enc:(fun _ -> "app.bsky.graph.getListsWithMembership#listWithMembership")
-  |> Jsont.Object.mem "list" Jsont.json ~enc:(fun r -> r.list_)
-  |> Jsont.Object.opt_mem "listItem" Jsont.json ~enc:(fun r -> r.list_item)
-  |> Jsont.Object.finish
-
+      module GetTimeline = struct
 type params = {
-  actor : string;
+  algorithm : string option;
   cursor : string option;
   limit : int option;
-  purposes : string list option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit purposes -> {
-      actor;
+    (fun algorithm cursor limit -> {
+      algorithm;
       cursor;
       limit;
-      purposes;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
+  |> Jsont.Object.opt_mem "algorithm" Jsont.string
+       ~enc:(fun r -> r.algorithm)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.purposes)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
-  lists_with_membership : Jsont.json list;
+  feed : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor lists_with_membership -> { cursor; lists_with_membership })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListsWithMembership#output" ~enc:(fun _ -> "app.bsky.graph.getListsWithMembership#output")
+    (fun _typ cursor feed -> { cursor; feed })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getTimeline#output" ~enc:(fun _ -> "app.bsky.feed.getTimeline#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "listsWithMembership" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists_with_membership)
+  |> Jsont.Object.mem "feed" (Jsont.list Jsont.json) ~enc:(fun r -> r.feed)
   |> Jsont.Object.finish
 
       end
-      module GetListMutes = struct
-type params = {
-  cursor : string option;
-  limit : int option;
+    end
+    module Bookmark = struct
+      module DeleteBookmark = struct
+type input = {
+  uri : string;
 }
 
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
-      limit;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  lists : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor lists -> { cursor; lists })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListMutes#output" ~enc:(fun _ -> "app.bsky.graph.getListMutes#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.deleteBookmark#input" ~enc:(fun _ -> "app.bsky.bookmark.deleteBookmark#input")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
       end
-      module GetActorStarterPacks = struct
-type params = {
-  actor : string;
-  cursor : string option;
-  limit : int option;
+      module CreateBookmark = struct
+type input = {
+  cid : string;
+  uri : string;
 }
 
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit -> {
-      actor;
-      cursor;
-      limit;
-    })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  starter_packs : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor starter_packs -> { cursor; starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getActorStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.getActorStarterPacks#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ cid uri -> { cid; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.createBookmark#input" ~enc:(fun _ -> "app.bsky.bookmark.createBookmark#input")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
       end
-      module SearchStarterPacks = struct
-type params = {
-  cursor : string option;
-  limit : int option;
-  q : string;
+      module Defs = struct
+type bookmark_view = {
+  created_at : string option;
+  item : Jsont.json;
+  subject : Com.Atproto.Repo.StrongRef.main;
 }
 
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor limit q -> {
-      cursor;
-      limit;
-      q;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.mem "q" Jsont.string
-       ~enc:(fun r -> r.q)
+let bookmark_view_jsont =
+  Jsont.Object.map ~kind:"Bookmark_view"
+    (fun _typ created_at item subject -> { created_at; item; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.defs#bookmarkView" ~enc:(fun _ -> "app.bsky.bookmark.defs#bookmarkView")
+  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "item" Jsont.json ~enc:(fun r -> r.item)
+  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
-type output = {
-  cursor : string option;
-  starter_packs : Jsont.json list;
+type bookmark = {
+  subject : Com.Atproto.Repo.StrongRef.main;
 }
 
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor starter_packs -> { cursor; starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.searchStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.searchStarterPacks#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
+let bookmark_jsont =
+  Jsont.Object.map ~kind:"Bookmark"
+    (fun _typ subject -> { subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.defs#bookmark" ~enc:(fun _ -> "app.bsky.bookmark.defs#bookmark")
+  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
       end
-      module GetStarterPacksWithMembership = struct
-type starter_pack_with_membership = {
-  list_item : Jsont.json option;
-  starter_pack : Jsont.json;
-}
-
-let starter_pack_with_membership_jsont =
-  Jsont.Object.map ~kind:"Starter_pack_with_membership"
-    (fun _typ list_item starter_pack -> { list_item; starter_pack })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership" ~enc:(fun _ -> "app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership")
-  |> Jsont.Object.opt_mem "listItem" Jsont.json ~enc:(fun r -> r.list_item)
-  |> Jsont.Object.mem "starterPack" Jsont.json ~enc:(fun r -> r.starter_pack)
-  |> Jsont.Object.finish
-
+      module GetBookmarks = struct
 type params = {
-  actor : string;
   cursor : string option;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit -> {
-      actor;
+    (fun cursor limit -> {
       cursor;
       limit;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
···
   |> Jsont.Object.finish
 
 type output = {
+  bookmarks : Defs.bookmark_view list;
   cursor : string option;
-  starter_packs_with_membership : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor starter_packs_with_membership -> { cursor; starter_packs_with_membership })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacksWithMembership#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPacksWithMembership#output")
+    (fun _typ bookmarks cursor -> { bookmarks; cursor })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.getBookmarks#output" ~enc:(fun _ -> "app.bsky.bookmark.getBookmarks#output")
+  |> Jsont.Object.mem "bookmarks" (Jsont.list Defs.bookmark_view_jsont) ~enc:(fun r -> r.bookmarks)
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "starterPacksWithMembership" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs_with_membership)
   |> Jsont.Object.finish
 
       end
-      module GetLists = struct
+    end
+    module Unspecced = struct
+      module GetSuggestedUsersSkeleton = struct
 type params = {
-  actor : string;
-  cursor : string option;
+  category : string option;
   limit : int option;
-  purposes : string list option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor cursor limit purposes -> {
-      actor;
-      cursor;
+    (fun category limit viewer -> {
+      category;
       limit;
-      purposes;
+      viewer;
     })
-  |> Jsont.Object.mem "actor" Jsont.string
-       ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "category" Jsont.string
+       ~enc:(fun r -> r.category)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.purposes)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  lists : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor lists -> { cursor; lists })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getLists#output" ~enc:(fun _ -> "app.bsky.graph.getLists#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
-  |> Jsont.Object.finish
-
-      end
-      module GetStarterPack = struct
-type params = {
-  starter_pack : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun starter_pack -> {
-      starter_pack;
-    })
-  |> Jsont.Object.mem "starterPack" Jsont.string
-       ~enc:(fun r -> r.starter_pack)
+  |> Jsont.Object.opt_mem "viewer" Jsont.string
+       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
-  starter_pack : Jsont.json;
+  dids : string list;
+  rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ starter_pack -> { starter_pack })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPack#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPack#output")
-  |> Jsont.Object.mem "starterPack" Jsont.json ~enc:(fun r -> r.starter_pack)
+    (fun _typ dids rec_id -> { dids; rec_id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedUsersSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedUsersSkeleton#output")
+  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string) ~enc:(fun r -> r.dids)
+  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
   |> Jsont.Object.finish
 
       end
-      module GetListBlocks = struct
+      module GetOnboardingSuggestedStarterPacks = struct
 type params = {
-  cursor : string option;
   limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
+    (fun limit -> {
       limit;
     })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
-  cursor : string option;
-  lists : Jsont.json list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor lists -> { cursor; lists })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getListBlocks#output" ~enc:(fun _ -> "app.bsky.graph.getListBlocks#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
-  |> Jsont.Object.finish
-
-      end
-      module GetStarterPacks = struct
-type params = {
-  uris : string list;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun uris -> {
-      uris;
-    })
-  |> Jsont.Object.mem "uris" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.uris)
-  |> Jsont.Object.finish
-
-type output = {
   starter_packs : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
     (fun _typ starter_packs -> { starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getStarterPacks#output" ~enc:(fun _ -> "app.bsky.graph.getStarterPacks#output")
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getOnboardingSuggestedStarterPacks#output" ~enc:(fun _ -> "app.bsky.unspecced.getOnboardingSuggestedStarterPacks#output")
   |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
       end
-      module GetList = struct
+      module GetPopularFeedGenerators = struct
 type params = {
   cursor : string option;
   limit : int option;
-  list_ : string;
+  query : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit list_ -> {
+    (fun cursor limit query -> {
       cursor;
       limit;
-      list_;
+      query;
     })
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.mem "list" Jsont.string
-       ~enc:(fun r -> r.list_)
+  |> Jsont.Object.opt_mem "query" Jsont.string
+       ~enc:(fun r -> r.query)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
-  items : Jsont.json list;
-  list_ : Jsont.json;
+  feeds : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor items list_ -> { cursor; items; list_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.getList#output" ~enc:(fun _ -> "app.bsky.graph.getList#output")
+    (fun _typ cursor feeds -> { cursor; feeds })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPopularFeedGenerators#output" ~enc:(fun _ -> "app.bsky.unspecced.getPopularFeedGenerators#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "items" (Jsont.list Jsont.json) ~enc:(fun r -> r.items)
-  |> Jsont.Object.mem "list" Jsont.json ~enc:(fun r -> r.list_)
+  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
   |> Jsont.Object.finish
 
       end
-      module List = struct
-type main = {
-  avatar : Atp.Blob_ref.t option;
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  name : string;
-  purpose : Jsont.json;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ avatar created_at description description_facets labels name purpose -> { avatar; created_at; description; description_facets; labels; name; purpose })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.list" ~enc:(fun _ -> "app.bsky.graph.list")
-  |> Jsont.Object.opt_mem "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "descriptionFacets" (Jsont.list Richtext.Facet.main_jsont) ~enc:(fun r -> r.description_facets)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Bookmark = struct
-      module Defs = struct
-type bookmark_view = {
-  created_at : string option;
-  item : Jsont.json;
-  subject : Com.Atproto.Repo.StrongRef.main;
-}
-
-let bookmark_view_jsont =
-  Jsont.Object.map ~kind:"Bookmark_view"
-    (fun _typ created_at item subject -> { created_at; item; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.defs#bookmarkView" ~enc:(fun _ -> "app.bsky.bookmark.defs#bookmarkView")
-  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "item" Jsont.json ~enc:(fun r -> r.item)
-  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-type bookmark = {
-  subject : Com.Atproto.Repo.StrongRef.main;
-}
-
-let bookmark_jsont =
-  Jsont.Object.map ~kind:"Bookmark"
-    (fun _typ subject -> { subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.defs#bookmark" ~enc:(fun _ -> "app.bsky.bookmark.defs#bookmark")
-  |> Jsont.Object.mem "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module CreateBookmark = struct
-type input = {
-  cid : string;
-  uri : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ cid uri -> { cid; uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.createBookmark#input" ~enc:(fun _ -> "app.bsky.bookmark.createBookmark#input")
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-      end
-      module DeleteBookmark = struct
-type input = {
-  uri : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.deleteBookmark#input" ~enc:(fun _ -> "app.bsky.bookmark.deleteBookmark#input")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-      end
-      module GetBookmarks = struct
+      module GetSuggestedStarterPacksSkeleton = struct
 type params = {
-  cursor : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
+    (fun limit viewer -> {
       limit;
+      viewer;
     })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "viewer" Jsont.string
+       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
-  bookmarks : Defs.bookmark_view list;
-  cursor : string option;
+  starter_packs : string list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ bookmarks cursor -> { bookmarks; cursor })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.getBookmarks#output" ~enc:(fun _ -> "app.bsky.bookmark.getBookmarks#output")
-  |> Jsont.Object.mem "bookmarks" (Jsont.list Defs.bookmark_view_jsont) ~enc:(fun r -> r.bookmarks)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+    (fun _typ starter_packs -> { starter_packs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedStarterPacksSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedStarterPacksSkeleton#output")
+  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.string) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
       end
-    end
-    module Unspecced = struct
       module GetSuggestedFeeds = struct
 type params = {
   limit : int option;
···
   |> Jsont.Object.finish
 
       end
-      module GetSuggestedUsers = struct
+      module GetSuggestedFeedsSkeleton = struct
 type params = {
-  category : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun category limit -> {
-      category;
+    (fun limit viewer -> {
       limit;
+      viewer;
     })
-  |> Jsont.Object.opt_mem "category" Jsont.string
-       ~enc:(fun r -> r.category)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "viewer" Jsont.string
+       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
-  actors : Jsont.json list;
-  rec_id : int option;
+  feeds : string list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ actors rec_id -> { actors; rec_id })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedUsers#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedUsers#output")
-  |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
+    (fun _typ feeds -> { feeds })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedFeedsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedFeedsSkeleton#output")
+  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.string) ~enc:(fun r -> r.feeds)
   |> Jsont.Object.finish
 
       end
-      module GetSuggestedUsersSkeleton = struct
-type params = {
-  category : string option;
-  limit : int option;
-  viewer : string option;
+      module GetConfig = struct
+type live_now_config = {
+  did : string;
+  domains : string list;
 }
 
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun category limit viewer -> {
-      category;
-      limit;
-      viewer;
-    })
-  |> Jsont.Object.opt_mem "category" Jsont.string
-       ~enc:(fun r -> r.category)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
+let live_now_config_jsont =
+  Jsont.Object.map ~kind:"Live_now_config"
+    (fun _typ did domains -> { did; domains })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getConfig#liveNowConfig" ~enc:(fun _ -> "app.bsky.unspecced.getConfig#liveNowConfig")
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.mem "domains" (Jsont.list Jsont.string) ~enc:(fun r -> r.domains)
   |> Jsont.Object.finish
 
 type output = {
-  dids : string list;
-  rec_id : int option;
+  check_email_confirmed : bool option;
+  live_now : live_now_config list option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ dids rec_id -> { dids; rec_id })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedUsersSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedUsersSkeleton#output")
-  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string) ~enc:(fun r -> r.dids)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
+    (fun _typ check_email_confirmed live_now -> { check_email_confirmed; live_now })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getConfig#output" ~enc:(fun _ -> "app.bsky.unspecced.getConfig#output")
+  |> Jsont.Object.opt_mem "checkEmailConfirmed" Jsont.bool ~enc:(fun r -> r.check_email_confirmed)
+  |> Jsont.Object.opt_mem "liveNow" (Jsont.list live_now_config_jsont) ~enc:(fun r -> r.live_now)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module GetOnboardingSuggestedStarterPacksSkeleton = struct
+      module GetSuggestedUsers = struct
 type params = {
+  category : string option;
   limit : int option;
-  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit viewer -> {
+    (fun category limit -> {
+      category;
       limit;
-      viewer;
     })
+  |> Jsont.Object.opt_mem "category" Jsont.string
+       ~enc:(fun r -> r.category)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
-  starter_packs : string list;
+  actors : Jsont.json list;
+  rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ starter_packs -> { starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton#output")
-  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.string) ~enc:(fun r -> r.starter_packs)
+    (fun _typ actors rec_id -> { actors; rec_id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedUsers#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedUsers#output")
+  |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
+  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
   |> Jsont.Object.finish
 
       end
-      module GetSuggestedFeedsSkeleton = struct
+      module GetOnboardingSuggestedStarterPacksSkeleton = struct
 type params = {
   limit : int option;
   viewer : string option;
···
   |> Jsont.Object.finish
 
 type output = {
-  feeds : string list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ feeds -> { feeds })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedFeedsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedFeedsSkeleton#output")
-  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.string) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.finish
-
-      end
-      module GetOnboardingSuggestedStarterPacks = struct
-type params = {
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun limit -> {
-      limit;
-    })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  starter_packs : Jsont.json list;
+  starter_packs : string list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
     (fun _typ starter_packs -> { starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getOnboardingSuggestedStarterPacks#output" ~enc:(fun _ -> "app.bsky.unspecced.getOnboardingSuggestedStarterPacks#output")
-  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.json) ~enc:(fun r -> r.starter_packs)
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton#output")
+  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.string) ~enc:(fun r -> r.starter_packs)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module GetConfig = struct
-type live_now_config = {
-  did : string;
-  domains : string list;
+      module GetTaggedSuggestions = struct
+type suggestion = {
+  subject : string;
+  subject_type : string;
+  tag : string;
 }
 
-let live_now_config_jsont =
-  Jsont.Object.map ~kind:"Live_now_config"
-    (fun _typ did domains -> { did; domains })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getConfig#liveNowConfig" ~enc:(fun _ -> "app.bsky.unspecced.getConfig#liveNowConfig")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "domains" (Jsont.list Jsont.string) ~enc:(fun r -> r.domains)
+let suggestion_jsont =
+  Jsont.Object.map ~kind:"Suggestion"
+    (fun _typ subject subject_type tag -> { subject; subject_type; tag })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTaggedSuggestions#suggestion" ~enc:(fun _ -> "app.bsky.unspecced.getTaggedSuggestions#suggestion")
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.mem "subjectType" Jsont.string ~enc:(fun r -> r.subject_type)
+  |> Jsont.Object.mem "tag" Jsont.string ~enc:(fun r -> r.tag)
   |> Jsont.Object.finish
 
+type params = unit
+
+let params_jsont = Jsont.ignore
+
 type output = {
-  check_email_confirmed : bool option;
-  live_now : live_now_config list option;
+  suggestions : suggestion list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ check_email_confirmed live_now -> { check_email_confirmed; live_now })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getConfig#output" ~enc:(fun _ -> "app.bsky.unspecced.getConfig#output")
-  |> Jsont.Object.opt_mem "checkEmailConfirmed" Jsont.bool ~enc:(fun r -> r.check_email_confirmed)
-  |> Jsont.Object.opt_mem "liveNow" (Jsont.list live_now_config_jsont) ~enc:(fun r -> r.live_now)
+    (fun _typ suggestions -> { suggestions })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTaggedSuggestions#output" ~enc:(fun _ -> "app.bsky.unspecced.getTaggedSuggestions#output")
+  |> Jsont.Object.mem "suggestions" (Jsont.list suggestion_jsont) ~enc:(fun r -> r.suggestions)
   |> Jsont.Object.finish
 
       end
-      module GetPopularFeedGenerators = struct
+      module SearchPostsSkeleton = struct
 type params = {
+  author : string option;
   cursor : string option;
+  domain : string option;
+  lang : string option;
   limit : int option;
-  query : string option;
+  mentions : string option;
+  q : string;
+  since : string option;
+  sort : string option;
+  tag : string list option;
+  until : string option;
+  url : string option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit query -> {
+    (fun author cursor domain lang limit mentions q since sort tag until url viewer -> {
+      author;
       cursor;
+      domain;
+      lang;
       limit;
-      query;
+      mentions;
+      q;
+      since;
+      sort;
+      tag;
+      until;
+      url;
+      viewer;
     })
+  |> Jsont.Object.opt_mem "author" Jsont.string
+       ~enc:(fun r -> r.author)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "domain" Jsont.string
+       ~enc:(fun r -> r.domain)
+  |> Jsont.Object.opt_mem "lang" Jsont.string
+       ~enc:(fun r -> r.lang)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "query" Jsont.string
-       ~enc:(fun r -> r.query)
+  |> Jsont.Object.opt_mem "mentions" Jsont.string
+       ~enc:(fun r -> r.mentions)
+  |> Jsont.Object.mem "q" Jsont.string
+       ~enc:(fun r -> r.q)
+  |> Jsont.Object.opt_mem "since" Jsont.string
+       ~enc:(fun r -> r.since)
+  |> Jsont.Object.opt_mem "sort" Jsont.string
+       ~enc:(fun r -> r.sort)
+  |> Jsont.Object.opt_mem "tag" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.tag)
+  |> Jsont.Object.opt_mem "until" Jsont.string
+       ~enc:(fun r -> r.until)
+  |> Jsont.Object.opt_mem "url" Jsont.string
+       ~enc:(fun r -> r.url)
+  |> Jsont.Object.opt_mem "viewer" Jsont.string
+       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
-  feeds : Jsont.json list;
+  hits_total : int option;
+  posts : Defs.skeleton_search_post list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor feeds -> { cursor; feeds })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPopularFeedGenerators#output" ~enc:(fun _ -> "app.bsky.unspecced.getPopularFeedGenerators#output")
+    (fun _typ cursor hits_total posts -> { cursor; hits_total; posts })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.searchPostsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.searchPostsSkeleton#output")
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
+  |> Jsont.Object.opt_mem "hitsTotal" Jsont.int ~enc:(fun r -> r.hits_total)
+  |> Jsont.Object.mem "posts" (Jsont.list Defs.skeleton_search_post_jsont) ~enc:(fun r -> r.posts)
   |> Jsont.Object.finish
 
       end
-      module GetTaggedSuggestions = struct
-type suggestion = {
-  subject : string;
-  subject_type : string;
-  tag : string;
+      module GetPostThreadV2 = struct
+type thread_item = {
+  depth : int;
+  uri : string;
+  value : Jsont.json;
 }
 
-let suggestion_jsont =
-  Jsont.Object.map ~kind:"Suggestion"
-    (fun _typ subject subject_type tag -> { subject; subject_type; tag })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTaggedSuggestions#suggestion" ~enc:(fun _ -> "app.bsky.unspecced.getTaggedSuggestions#suggestion")
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "subjectType" Jsont.string ~enc:(fun r -> r.subject_type)
-  |> Jsont.Object.mem "tag" Jsont.string ~enc:(fun r -> r.tag)
+let thread_item_jsont =
+  Jsont.Object.map ~kind:"Thread_item"
+    (fun _typ depth uri value -> { depth; uri; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPostThreadV2#threadItem" ~enc:(fun _ -> "app.bsky.unspecced.getPostThreadV2#threadItem")
+  |> Jsont.Object.mem "depth" Jsont.int ~enc:(fun r -> r.depth)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
-type params = unit
+type params = {
+  above : bool option;
+  anchor : string;
+  below : int option;
+  branching_factor : int option;
+  sort : string option;
+}
 
-let params_jsont = Jsont.ignore
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun above anchor below branching_factor sort -> {
+      above;
+      anchor;
+      below;
+      branching_factor;
+      sort;
+    })
+  |> Jsont.Object.opt_mem "above" Jsont.bool
+       ~enc:(fun r -> r.above)
+  |> Jsont.Object.mem "anchor" Jsont.string
+       ~enc:(fun r -> r.anchor)
+  |> Jsont.Object.opt_mem "below" Jsont.int
+       ~enc:(fun r -> r.below)
+  |> Jsont.Object.opt_mem "branchingFactor" Jsont.int
+       ~enc:(fun r -> r.branching_factor)
+  |> Jsont.Object.opt_mem "sort" Jsont.string
+       ~enc:(fun r -> r.sort)
+  |> Jsont.Object.finish
 
 type output = {
-  suggestions : suggestion list;
+  has_other_replies : bool;
+  thread : thread_item list;
+  threadgate : Jsont.json option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ suggestions -> { suggestions })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTaggedSuggestions#output" ~enc:(fun _ -> "app.bsky.unspecced.getTaggedSuggestions#output")
-  |> Jsont.Object.mem "suggestions" (Jsont.list suggestion_jsont) ~enc:(fun r -> r.suggestions)
+    (fun _typ has_other_replies thread threadgate -> { has_other_replies; thread; threadgate })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPostThreadV2#output" ~enc:(fun _ -> "app.bsky.unspecced.getPostThreadV2#output")
+  |> Jsont.Object.mem "hasOtherReplies" Jsont.bool ~enc:(fun r -> r.has_other_replies)
+  |> Jsont.Object.mem "thread" (Jsont.list thread_item_jsont) ~enc:(fun r -> r.thread)
+  |> Jsont.Object.opt_mem "threadgate" Jsont.json ~enc:(fun r -> r.threadgate)
   |> Jsont.Object.finish
 
       end
-      module GetSuggestedStarterPacksSkeleton = struct
+      module GetTrendingTopics = struct
 type params = {
   limit : int option;
   viewer : string option;
···
   |> Jsont.Object.finish
 
 type output = {
-  starter_packs : string list;
+  suggested : Defs.trending_topic list;
+  topics : Defs.trending_topic list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ starter_packs -> { starter_packs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestedStarterPacksSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestedStarterPacksSkeleton#output")
-  |> Jsont.Object.mem "starterPacks" (Jsont.list Jsont.string) ~enc:(fun r -> r.starter_packs)
+    (fun _typ suggested topics -> { suggested; topics })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTrendingTopics#output" ~enc:(fun _ -> "app.bsky.unspecced.getTrendingTopics#output")
+  |> Jsont.Object.mem "suggested" (Jsont.list Defs.trending_topic_jsont) ~enc:(fun r -> r.suggested)
+  |> Jsont.Object.mem "topics" (Jsont.list Defs.trending_topic_jsont) ~enc:(fun r -> r.topics)
   |> Jsont.Object.finish
 
       end
-      module InitAgeAssurance = struct
-type input = {
-  country_code : string;
-  email : string;
-  language : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ country_code email language -> { country_code; email; language })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.initAgeAssurance#input" ~enc:(fun _ -> "app.bsky.unspecced.initAgeAssurance#input")
-  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
-  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.mem "language" Jsont.string ~enc:(fun r -> r.language)
-  |> Jsont.Object.finish
-
-type output = Defs.age_assurance_state
-
-let output_jsont = Defs.age_assurance_state_jsont
-
-      end
-      module GetTrendingTopics = struct
+      module GetTrendsSkeleton = struct
 type params = {
   limit : int option;
   viewer : string option;
···
   |> Jsont.Object.finish
 
 type output = {
-  suggested : Defs.trending_topic list;
-  topics : Defs.trending_topic list;
+  trends : Defs.skeleton_trend list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ suggested topics -> { suggested; topics })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTrendingTopics#output" ~enc:(fun _ -> "app.bsky.unspecced.getTrendingTopics#output")
-  |> Jsont.Object.mem "suggested" (Jsont.list Defs.trending_topic_jsont) ~enc:(fun r -> r.suggested)
-  |> Jsont.Object.mem "topics" (Jsont.list Defs.trending_topic_jsont) ~enc:(fun r -> r.topics)
+    (fun _typ trends -> { trends })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTrendsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getTrendsSkeleton#output")
+  |> Jsont.Object.mem "trends" (Jsont.list Defs.skeleton_trend_jsont) ~enc:(fun r -> r.trends)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module GetSuggestionsSkeleton = struct
-type params = {
-  cursor : string option;
-  limit : int option;
-  relative_to_did : string option;
-  viewer : string option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor limit relative_to_did viewer -> {
-      cursor;
-      limit;
-      relative_to_did;
-      viewer;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "relativeToDid" Jsont.string
-       ~enc:(fun r -> r.relative_to_did)
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type output = {
-  actors : Defs.skeleton_search_actor list;
-  cursor : string option;
-  rec_id : int option;
-  relative_to_did : string option;
+      module InitAgeAssurance = struct
+type input = {
+  country_code : string;
+  email : string;
+  language : string;
 }
 
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ actors cursor rec_id relative_to_did -> { actors; cursor; rec_id; relative_to_did })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestionsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestionsSkeleton#output")
-  |> Jsont.Object.mem "actors" (Jsont.list Defs.skeleton_search_actor_jsont) ~enc:(fun r -> r.actors)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
-  |> Jsont.Object.opt_mem "relativeToDid" Jsont.string ~enc:(fun r -> r.relative_to_did)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ country_code email language -> { country_code; email; language })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.initAgeAssurance#input" ~enc:(fun _ -> "app.bsky.unspecced.initAgeAssurance#input")
+  |> Jsont.Object.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
+  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
+  |> Jsont.Object.mem "language" Jsont.string ~enc:(fun r -> r.language)
   |> Jsont.Object.finish
 
-      end
-      module GetAgeAssuranceState = struct
 type output = Defs.age_assurance_state
 
 let output_jsont = Defs.age_assurance_state_jsont
···
   |> Jsont.Object.finish
 
       end
-      module SearchPostsSkeleton = struct
+      module SearchActorsSkeleton = struct
 type params = {
-  author : string option;
   cursor : string option;
-  domain : string option;
-  lang : string option;
   limit : int option;
-  mentions : string option;
   q : string;
-  since : string option;
-  sort : string option;
-  tag : string list option;
-  until : string option;
-  url : string option;
+  typeahead : bool option;
   viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun author cursor domain lang limit mentions q since sort tag until url viewer -> {
-      author;
+    (fun cursor limit q typeahead viewer -> {
       cursor;
-      domain;
-      lang;
       limit;
-      mentions;
       q;
-      since;
-      sort;
-      tag;
-      until;
-      url;
+      typeahead;
       viewer;
     })
-  |> Jsont.Object.opt_mem "author" Jsont.string
-       ~enc:(fun r -> r.author)
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "domain" Jsont.string
-       ~enc:(fun r -> r.domain)
-  |> Jsont.Object.opt_mem "lang" Jsont.string
-       ~enc:(fun r -> r.lang)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "mentions" Jsont.string
-       ~enc:(fun r -> r.mentions)
   |> Jsont.Object.mem "q" Jsont.string
        ~enc:(fun r -> r.q)
-  |> Jsont.Object.opt_mem "since" Jsont.string
-       ~enc:(fun r -> r.since)
-  |> Jsont.Object.opt_mem "sort" Jsont.string
-       ~enc:(fun r -> r.sort)
-  |> Jsont.Object.opt_mem "tag" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.tag)
-  |> Jsont.Object.opt_mem "until" Jsont.string
-       ~enc:(fun r -> r.until)
-  |> Jsont.Object.opt_mem "url" Jsont.string
-       ~enc:(fun r -> r.url)
+  |> Jsont.Object.opt_mem "typeahead" Jsont.bool
+       ~enc:(fun r -> r.typeahead)
   |> Jsont.Object.opt_mem "viewer" Jsont.string
        ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type output = {
+  actors : Defs.skeleton_search_actor list;
   cursor : string option;
   hits_total : int option;
-  posts : Defs.skeleton_search_post list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor hits_total posts -> { cursor; hits_total; posts })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.searchPostsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.searchPostsSkeleton#output")
+    (fun _typ actors cursor hits_total -> { actors; cursor; hits_total })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.searchActorsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.searchActorsSkeleton#output")
+  |> Jsont.Object.mem "actors" (Jsont.list Defs.skeleton_search_actor_jsont) ~enc:(fun r -> r.actors)
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "hitsTotal" Jsont.int ~enc:(fun r -> r.hits_total)
-  |> Jsont.Object.mem "posts" (Jsont.list Defs.skeleton_search_post_jsont) ~enc:(fun r -> r.posts)
   |> Jsont.Object.finish
 
       end
-      module SearchActorsSkeleton = struct
+      module GetAgeAssuranceState = struct
+type output = Defs.age_assurance_state
+
+let output_jsont = Defs.age_assurance_state_jsont
+
+      end
+      module GetSuggestionsSkeleton = struct
 type params = {
   cursor : string option;
   limit : int option;
-  q : string;
-  typeahead : bool option;
+  relative_to_did : string option;
   viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit q typeahead viewer -> {
+    (fun cursor limit relative_to_did viewer -> {
       cursor;
       limit;
-      q;
-      typeahead;
+      relative_to_did;
       viewer;
     })
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.mem "q" Jsont.string
-       ~enc:(fun r -> r.q)
-  |> Jsont.Object.opt_mem "typeahead" Jsont.bool
-       ~enc:(fun r -> r.typeahead)
+  |> Jsont.Object.opt_mem "relativeToDid" Jsont.string
+       ~enc:(fun r -> r.relative_to_did)
   |> Jsont.Object.opt_mem "viewer" Jsont.string
        ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
···
 type output = {
   actors : Defs.skeleton_search_actor list;
   cursor : string option;
-  hits_total : int option;
+  rec_id : int option;
+  relative_to_did : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ actors cursor hits_total -> { actors; cursor; hits_total })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.searchActorsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.searchActorsSkeleton#output")
+    (fun _typ actors cursor rec_id relative_to_did -> { actors; cursor; rec_id; relative_to_did })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getSuggestionsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getSuggestionsSkeleton#output")
   |> Jsont.Object.mem "actors" (Jsont.list Defs.skeleton_search_actor_jsont) ~enc:(fun r -> r.actors)
   |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "hitsTotal" Jsont.int ~enc:(fun r -> r.hits_total)
+  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
+  |> Jsont.Object.opt_mem "relativeToDid" Jsont.string ~enc:(fun r -> r.relative_to_did)
   |> Jsont.Object.finish
 
       end
···
     (fun _typ trends -> { trends })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTrends#output" ~enc:(fun _ -> "app.bsky.unspecced.getTrends#output")
   |> Jsont.Object.mem "trends" (Jsont.list Defs.trend_view_jsont) ~enc:(fun r -> r.trends)
-  |> Jsont.Object.finish
-
-      end
-      module GetPostThreadV2 = struct
-type thread_item = {
-  depth : int;
-  uri : string;
-  value : Jsont.json;
-}
-
-let thread_item_jsont =
-  Jsont.Object.map ~kind:"Thread_item"
-    (fun _typ depth uri value -> { depth; uri; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPostThreadV2#threadItem" ~enc:(fun _ -> "app.bsky.unspecced.getPostThreadV2#threadItem")
-  |> Jsont.Object.mem "depth" Jsont.int ~enc:(fun r -> r.depth)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
-  |> Jsont.Object.finish
-
-type params = {
-  above : bool option;
-  anchor : string;
-  below : int option;
-  branching_factor : int option;
-  sort : string option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun above anchor below branching_factor sort -> {
-      above;
-      anchor;
-      below;
-      branching_factor;
-      sort;
-    })
-  |> Jsont.Object.opt_mem "above" Jsont.bool
-       ~enc:(fun r -> r.above)
-  |> Jsont.Object.mem "anchor" Jsont.string
-       ~enc:(fun r -> r.anchor)
-  |> Jsont.Object.opt_mem "below" Jsont.int
-       ~enc:(fun r -> r.below)
-  |> Jsont.Object.opt_mem "branchingFactor" Jsont.int
-       ~enc:(fun r -> r.branching_factor)
-  |> Jsont.Object.opt_mem "sort" Jsont.string
-       ~enc:(fun r -> r.sort)
-  |> Jsont.Object.finish
-
-type output = {
-  has_other_replies : bool;
-  thread : thread_item list;
-  threadgate : Jsont.json option;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ has_other_replies thread threadgate -> { has_other_replies; thread; threadgate })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPostThreadV2#output" ~enc:(fun _ -> "app.bsky.unspecced.getPostThreadV2#output")
-  |> Jsont.Object.mem "hasOtherReplies" Jsont.bool ~enc:(fun r -> r.has_other_replies)
-  |> Jsont.Object.mem "thread" (Jsont.list thread_item_jsont) ~enc:(fun r -> r.thread)
-  |> Jsont.Object.opt_mem "threadgate" Jsont.json ~enc:(fun r -> r.threadgate)
-  |> Jsont.Object.finish
-
-      end
-      module GetTrendsSkeleton = struct
-type params = {
-  limit : int option;
-  viewer : string option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun limit viewer -> {
-      limit;
-      viewer;
-    })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type output = {
-  trends : Defs.skeleton_trend list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ trends -> { trends })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getTrendsSkeleton#output" ~enc:(fun _ -> "app.bsky.unspecced.getTrendsSkeleton#output")
-  |> Jsont.Object.mem "trends" (Jsont.list Defs.skeleton_trend_jsont) ~enc:(fun r -> r.trends)
   |> Jsont.Object.finish
 
       end

lexicons/bsky/atp_lexicon_bsky.mli

···
 
 module Com : sig
   module Atproto : sig
-    module Moderation : sig
-      module Defs : sig
-(** Tag describing a type of subject that might be reported. *)
-
-type subject_type = string
-val subject_type_jsont : subject_type Jsont.t
-
-(** Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`. *)
-
-type reason_violation = string
-val reason_violation_jsont : reason_violation Jsont.t
-
-
-type reason_type = string
-val reason_type_jsont : reason_type Jsont.t
-
-(** Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`. *)
-
-type reason_spam = string
-val reason_spam_jsont : reason_spam Jsont.t
-
-(** Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`. *)
-
-type reason_sexual = string
-val reason_sexual_jsont : reason_sexual Jsont.t
-
-(** Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`. *)
-
-type reason_rude = string
-val reason_rude_jsont : reason_rude Jsont.t
-
-(** Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`. *)
-
-type reason_other = string
-val reason_other_jsont : reason_other Jsont.t
-
-(** Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`. *)
-
-type reason_misleading = string
-val reason_misleading_jsont : reason_misleading Jsont.t
-
-(** Appeal a previously taken moderation action *)
-
-type reason_appeal = string
-val reason_appeal_jsont : reason_appeal Jsont.t
-
-      end
-    end
     module Label : sig
       module Defs : sig
 (** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. *)
···
 
       end
     end
+    module Moderation : sig
+      module Defs : sig
+(** Tag describing a type of subject that might be reported. *)
+
+type subject_type = string
+val subject_type_jsont : subject_type Jsont.t
+
+(** Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`. *)
+
+type reason_violation = string
+val reason_violation_jsont : reason_violation Jsont.t
+
+
+type reason_type = string
+val reason_type_jsont : reason_type Jsont.t
+
+(** Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`. *)
+
+type reason_spam = string
+val reason_spam_jsont : reason_spam Jsont.t
+
+(** Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`. *)
+
+type reason_sexual = string
+val reason_sexual_jsont : reason_sexual Jsont.t
+
+(** Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`. *)
+
+type reason_rude = string
+val reason_rude_jsont : reason_rude Jsont.t
+
+(** Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`. *)
+
+type reason_other = string
+val reason_other_jsont : reason_other Jsont.t
+
+(** Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`. *)
+
+type reason_misleading = string
+val reason_misleading_jsont : reason_misleading Jsont.t
+
+(** Appeal a previously taken moderation action *)
+
+type reason_appeal = string
+val reason_appeal_jsont : reason_appeal Jsont.t
+
+      end
+    end
   end
 end
 module App : sig
   module Bsky : sig
-    module AuthFullApp : sig
+    module AuthManageLabelerService : sig
 
 type main = unit
 val main_jsont : main Jsont.t
···
 val main_jsont : main Jsont.t
 
     end
+    module AuthManageModeration : sig
+
+type main = unit
+val main_jsont : main Jsont.t
+
+    end
+    module Richtext : sig
+      module Facet : sig
+(** Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags'). *)
+
+type tag = {
+  tag : string;
+}
+
+(** Jsont codec for {!type:tag}. *)
+val tag_jsont : tag Jsont.t
+
+(** Facet feature for mention of another account. The text is usually a handle, including a '\@' prefix, but the facet reference is a DID. *)
+
+type mention = {
+  did : string;
+}
+
+(** Jsont codec for {!type:mention}. *)
+val mention_jsont : mention Jsont.t
+
+(** Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL. *)
+
+type link = {
+  uri : string;
+}
+
+(** Jsont codec for {!type:link}. *)
+val link_jsont : link Jsont.t
+
+(** Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets. *)
+
+type byte_slice = {
+  byte_end : int;
+  byte_start : int;
+}
+
+(** Jsont codec for {!type:byte_slice}. *)
+val byte_slice_jsont : byte_slice Jsont.t
+
+(** Annotation of a sub-string within rich text. *)
+
+type main = {
+  features : Jsont.json list;
+  index : byte_slice;
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+    end
     module AuthManageFeedDeclarations : sig
 
 type main = unit
 val main_jsont : main Jsont.t
 
     end
-    module AuthManageNotifications : sig
+    module AuthFullApp : sig
 
 type main = unit
 val main_jsont : main Jsont.t
 
     end
-    module AuthManageModeration : sig
+    module AuthManageNotifications : sig
 
 type main = unit
 val main_jsont : main Jsont.t
···
 val main_jsont : main Jsont.t
 
     end
-    module AuthManageLabelerService : sig
+    module Ageassurance : sig
+      module Defs : sig
+(** The status of the Age Assurance process. *)
+
+type status = string
+val status_jsont : status Jsont.t
+
+(** Additional metadata needed to compute Age Assurance state client-side. *)
+
+type state_metadata = {
+  account_created_at : string option;  (** The account creation timestamp. *)
+}
+
+(** Jsont codec for {!type:state_metadata}. *)
+val state_metadata_jsont : state_metadata Jsont.t
+
+(** Object used to store Age Assurance data in stash. *)
+
+type event = {
+  access : string;  (** The access level granted based on Age Assurance data we've processed. *)
+  attempt_id : string;  (** The unique identifier for this instance of the Age Assurance flow, in UUID format. *)
+  complete_ip : string option;  (** The IP address used when completing the Age Assurance flow. *)
+  complete_ua : string option;  (** The user agent used when completing the Age Assurance flow. *)
+  country_code : string;  (** The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow. *)
+  created_at : string;  (** The date and time of this write operation. *)
+  email : string option;  (** The email used for Age Assurance. *)
+  init_ip : string option;  (** The IP address used when initiating the Age Assurance flow. *)
+  init_ua : string option;  (** The user agent used when initiating the Age Assurance flow. *)
+  region_code : string option;  (** The ISO 3166-2 region code provided when beginning the Age Assurance flow. *)
+  status : string;  (** The status of the Age Assurance process. *)
+}
+
+(** Jsont codec for {!type:event}. *)
+val event_jsont : event Jsont.t
+
+(** The Age Assurance configuration for a specific region. *)
+
+type config_region = {
+  country_code : string;  (** The ISO 3166-1 alpha-2 country code this configuration applies to. *)
+  min_access_age : int;  (** The minimum age (as a whole integer) required to use Bluesky in this region. *)
+  region_code : string option;  (** The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country. *)
+  rules : Jsont.json list;  (** The ordered list of Age Assurance rules that apply to this region. Rules should be applied in order, and the first matching rule determines the access level granted. The rules array should always include a default rule as the last item. *)
+}
+
+(** Jsont codec for {!type:config_region}. *)
+val config_region_jsont : config_region Jsont.t
+
+(** The access level granted based on Age Assurance data we've processed. *)
+
+type access = string
+val access_jsont : access Jsont.t
+
+(** The user's computed Age Assurance state. *)
+
+type state = {
+  access : access;
+  last_initiated_at : string option;  (** The timestamp when this state was last updated. *)
+  status : status;
+}
+
+(** Jsont codec for {!type:state}. *)
+val state_jsont : state Jsont.t
+
+(** Age Assurance rule that applies if the user has declared themselves under a certain age. *)
+
+type config_region_rule_if_declared_under_age = {
+  access : access;
+  age : int;  (** The age threshold as a whole integer. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_declared_under_age}. *)
+val config_region_rule_if_declared_under_age_jsont : config_region_rule_if_declared_under_age Jsont.t
+
+(** Age Assurance rule that applies if the user has declared themselves equal-to or over a certain age. *)
+
+type config_region_rule_if_declared_over_age = {
+  access : access;
+  age : int;  (** The age threshold as a whole integer. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_declared_over_age}. *)
+val config_region_rule_if_declared_over_age_jsont : config_region_rule_if_declared_over_age Jsont.t
+
+(** Age Assurance rule that applies if the user has been assured to be under a certain age. *)
+
+type config_region_rule_if_assured_under_age = {
+  access : access;
+  age : int;  (** The age threshold as a whole integer. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_assured_under_age}. *)
+val config_region_rule_if_assured_under_age_jsont : config_region_rule_if_assured_under_age Jsont.t
+
+(** Age Assurance rule that applies if the user has been assured to be equal-to or over a certain age. *)
+
+type config_region_rule_if_assured_over_age = {
+  access : access;
+  age : int;  (** The age threshold as a whole integer. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_assured_over_age}. *)
+val config_region_rule_if_assured_over_age_jsont : config_region_rule_if_assured_over_age Jsont.t
+
+(** Age Assurance rule that applies if the account is older than a certain date. *)
+
+type config_region_rule_if_account_older_than = {
+  access : access;
+  date : string;  (** The date threshold as a datetime string. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_account_older_than}. *)
+val config_region_rule_if_account_older_than_jsont : config_region_rule_if_account_older_than Jsont.t
+
+(** Age Assurance rule that applies if the account is equal-to or newer than a certain date. *)
+
+type config_region_rule_if_account_newer_than = {
+  access : access;
+  date : string;  (** The date threshold as a datetime string. *)
+}
+
+(** Jsont codec for {!type:config_region_rule_if_account_newer_than}. *)
+val config_region_rule_if_account_newer_than_jsont : config_region_rule_if_account_newer_than Jsont.t
+
+(** Age Assurance rule that applies by default. *)
+
+type config_region_rule_default = {
+  access : access;
+}
+
+(** Jsont codec for {!type:config_region_rule_default}. *)
+val config_region_rule_default_jsont : config_region_rule_default Jsont.t
+
+
+type config = {
+  regions : config_region list;  (** The per-region Age Assurance configuration. *)
+}
+
+(** Jsont codec for {!type:config}. *)
+val config_jsont : config Jsont.t
+
+      end
+      module Begin : sig
+(** Initiate Age Assurance for an account. *)
+
+
+type input = {
+  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
+  email : string;  (** The user's email address to receive Age Assurance instructions. *)
+  language : string;  (** The user's preferred language for communication during the Age Assurance process. *)
+  region_code : string option;  (** An optional ISO 3166-2 code of the user's region or state within the country. *)
+}
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+
+type output = Defs.state
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+      module GetState : sig
+(** Returns server-computed Age Assurance state, if available, and any additional metadata needed to compute Age Assurance state client-side. *)
+
+(** Query/procedure parameters. *)
+type params = {
+  country_code : string;
+  region_code : string option;
+}
+
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
+
+
+type output = {
+  metadata : Defs.state_metadata;
+  state : Defs.state;
+}
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+      module GetConfig : sig
+(** Returns Age Assurance configuration for use on the client. *)
+
+
+type output = Defs.config
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+    end
+    module Labeler : sig
+      module Defs : sig
+
+type labeler_viewer_state = {
+  like : string option;
+}
+
+(** Jsont codec for {!type:labeler_viewer_state}. *)
+val labeler_viewer_state_jsont : labeler_viewer_state Jsont.t
+
+
+type labeler_policies = {
+  label_value_definitions : Com.Atproto.Label.Defs.label_value_definition list option;  (** Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler. *)
+  label_values : Com.Atproto.Label.Defs.label_value list;  (** The label values which this labeler publishes. May include global or custom labels. *)
+}
+
+(** Jsont codec for {!type:labeler_policies}. *)
+val labeler_policies_jsont : labeler_policies Jsont.t
+
+
+type labeler_view_detailed = {
+  cid : string;
+  creator : Jsont.json;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  policies : Jsont.json;
+  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;  (** The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed. *)
+  subject_collections : string list option;  (** Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type. *)
+  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
+  uri : string;
+  viewer : Jsont.json option;
+}
+
+(** Jsont codec for {!type:labeler_view_detailed}. *)
+val labeler_view_detailed_jsont : labeler_view_detailed Jsont.t
+
+
+type labeler_view = {
+  cid : string;
+  creator : Jsont.json;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  uri : string;
+  viewer : Jsont.json option;
+}
+
+(** Jsont codec for {!type:labeler_view}. *)
+val labeler_view_jsont : labeler_view Jsont.t
+
+      end
+      module Service : sig
+(** A declaration of the existence of labeler service. *)
+
+type main = {
+  created_at : string;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  policies : Jsont.json;
+  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;  (** The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed. *)
+  subject_collections : string list option;  (** Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type. *)
+  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module GetServices : sig
+(** Get information about a list of labeler services. *)
+
+(** Query/procedure parameters. *)
+type params = {
+  detailed : bool option;
+  dids : string list;
+}
+
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
+
+
+type output = {
+  views : Jsont.json list;
+}
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+    end
+    module AuthCreatePosts : sig
 
 type main = unit
 val main_jsont : main Jsont.t
 
     end
-    module Notification : sig
-      module GetUnreadCount : sig
-(** Count the number of unread notifications for the requesting account. Requires auth. *)
+    module Video : sig
+      module GetUploadLimits : sig
+(** Get video upload limits for the authenticated user. *)
+
+
+type output = {
+  can_upload : bool;
+  error : string option;
+  message : string option;
+  remaining_daily_bytes : int option;
+  remaining_daily_videos : int option;
+}
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+      module Defs : sig
+
+type job_status = {
+  blob : Atp.Blob_ref.t option;
+  did : string;
+  error : string option;
+  job_id : string;
+  message : string option;
+  progress : int option;  (** Progress within the current processing state. *)
+  state : string;  (** The state of the video processing job. All values not listed as a known value indicate that the job is in process. *)
+}
+
+(** Jsont codec for {!type:job_status}. *)
+val job_status_jsont : job_status Jsont.t
+
+      end
+      module UploadVideo : sig
+(** Upload a video to be processed then stored on the PDS. *)
+
+
+type input = unit
+val input_jsont : input Jsont.t
+
+
+type output = {
+  job_status : Defs.job_status;
+}
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+      module GetJobStatus : sig
+(** Get status details for a video processing job. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  priority : bool option;
-  seen_at : string option;
+  job_id : string;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  count : int;
+  job_status : Defs.job_status;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
+    end
+    module Embed : sig
+      module External : sig
+
+type view_external = {
+  description : string;
+  thumb : string option;
+  title : string;
+  uri : string;
+}
+
+(** Jsont codec for {!type:view_external}. *)
+val view_external_jsont : view_external Jsont.t
+
+
+type external_ = {
+  description : string;
+  thumb : Atp.Blob_ref.t option;
+  title : string;
+  uri : string;
+}
+
+(** Jsont codec for {!type:external_}. *)
+val external__jsont : external_ Jsont.t
+
+
+type view = {
+  external_ : Jsont.json;
+}
+
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
+
+(** A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post). *)
+
+type main = {
+  external_ : Jsont.json;
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module Defs : sig
+(** width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit. *)
+
+type aspect_ratio = {
+  height : int;
+  width : int;
+}
+
+(** Jsont codec for {!type:aspect_ratio}. *)
+val aspect_ratio_jsont : aspect_ratio Jsont.t
+
+      end
+      module Images : sig
+
+type view_image = {
+  alt : string;  (** Alt text description of the image, for accessibility. *)
+  aspect_ratio : Jsont.json option;
+  fullsize : string;  (** Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View. *)
+  thumb : string;  (** Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View. *)
+}
+
+(** Jsont codec for {!type:view_image}. *)
+val view_image_jsont : view_image Jsont.t
+
+
+type image = {
+  alt : string;  (** Alt text description of the image, for accessibility. *)
+  aspect_ratio : Jsont.json option;
+  image : Atp.Blob_ref.t;
+}
+
+(** Jsont codec for {!type:image}. *)
+val image_jsont : image Jsont.t
+
+
+type view = {
+  images : Jsont.json list;
+}
+
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
+
+
+type main = {
+  images : Jsont.json list;
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module Video : sig
+
+type view = {
+  alt : string option;
+  aspect_ratio : Jsont.json option;
+  cid : string;
+  playlist : string;
+  thumbnail : string option;
+}
+
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
+
+
+type caption = {
+  file : Atp.Blob_ref.t;
+  lang : string;
+}
+
+(** Jsont codec for {!type:caption}. *)
+val caption_jsont : caption Jsont.t
+
+
+type main = {
+  alt : string option;  (** Alt text description of the video, for accessibility. *)
+  aspect_ratio : Jsont.json option;
+  captions : Jsont.json list option;
+  video : Atp.Blob_ref.t;  (** The mp4 video file. May be up to 100mb, formerly limited to 50mb. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module RecordWithMedia : sig
+
+type view = {
+  media : Jsont.json;
+  record : Jsont.json;
+}
+
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
+
+
+type main = {
+  media : Jsont.json;
+  record : Jsont.json;
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module Record : sig
+
+type view_record = {
+  author : Jsont.json;
+  cid : string;
+  embeds : Jsont.json list option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  quote_count : int option;
+  reply_count : int option;
+  repost_count : int option;
+  uri : string;
+  value : Jsont.json;  (** The record data itself. *)
+}
+
+(** Jsont codec for {!type:view_record}. *)
+val view_record_jsont : view_record Jsont.t
+
+
+type view_not_found = {
+  not_found : bool;
+  uri : string;
+}
+
+(** Jsont codec for {!type:view_not_found}. *)
+val view_not_found_jsont : view_not_found Jsont.t
+
+
+type view_detached = {
+  detached : bool;
+  uri : string;
+}
+
+(** Jsont codec for {!type:view_detached}. *)
+val view_detached_jsont : view_detached Jsont.t
+
+
+type view_blocked = {
+  author : Jsont.json;
+  blocked : bool;
+  uri : string;
+}
+
+(** Jsont codec for {!type:view_blocked}. *)
+val view_blocked_jsont : view_blocked Jsont.t
+
+
+type view = {
+  record : Jsont.json;
+}
+
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
+
+
+type main = {
+  record : Com.Atproto.Repo.StrongRef.main;
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+    end
+    module Notification : sig
       module UpdateSeen : sig
 (** Notify server that the requesting account has seen notifications. Requires auth. *)
 
···
 val input_jsont : input Jsont.t
 
       end
+      module RegisterPush : sig
+(** Register to receive push notifications, via a specified service, for the requesting account. Requires auth. *)
+
+
+type input = {
+  age_restricted : bool option;  (** Set to true when the actor is age restricted *)
+  app_id : string;
+  platform : string;
+  service_did : string;
+  token : string;
+}
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+      end
       module ListNotifications : sig
 
 type notification = {
···
 val output_jsont : output Jsont.t
 
       end
-      module Declaration : sig
-(** A declaration of the user's choices related to notifications that can be produced by them. *)
+      module GetUnreadCount : sig
+(** Count the number of unread notifications for the requesting account. Requires auth. *)
 
-type main = {
-  allow_subscriptions : string;  (** A declaration of the user's preference for allowing activity subscriptions from other users. Absence of a record implies 'followers'. *)
+(** Query/procedure parameters. *)
+type params = {
+  priority : bool option;
+  seen_at : string option;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-      end
-      module PutPreferences : sig
-(** Set notification-related preferences for an account. Requires auth. *)
 
-
-type input = {
-  priority : bool;
+type output = {
+  count : int;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-      module RegisterPush : sig
-(** Register to receive push notifications, via a specified service, for the requesting account. Requires auth. *)
+      module UnregisterPush : sig
+(** The inverse of registerPush - inform a specified service that push notifications should no longer be sent to the given token for the requesting account. Requires auth. *)
 
 
 type input = {
-  age_restricted : bool option;  (** Set to true when the actor is age restricted *)
   app_id : string;
   platform : string;
   service_did : string;
···
 val input_jsont : input Jsont.t
 
       end
-      module UnregisterPush : sig
-(** The inverse of registerPush - inform a specified service that push notifications should no longer be sent to the given token for the requesting account. Requires auth. *)
+      module PutPreferences : sig
+(** Set notification-related preferences for an account. Requires auth. *)
 
 
 type input = {
-  app_id : string;
-  platform : string;
-  service_did : string;
-  token : string;
+  priority : bool;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 (** Jsont codec for {!type:preferences}. *)
 val preferences_jsont : preferences Jsont.t
+
+      end
+      module Declaration : sig
+(** A declaration of the user's choices related to notifications that can be produced by them. *)
+
+type main = {
+  allow_subscriptions : string;  (** A declaration of the user's preference for allowing activity subscriptions from other users. Absence of a record implies 'followers'. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
       module ListActivitySubscriptions : sig
···
 
       end
     end
-    module Labeler : sig
-      module Defs : sig
-
-type labeler_viewer_state = {
-  like : string option;
-}
-
-(** Jsont codec for {!type:labeler_viewer_state}. *)
-val labeler_viewer_state_jsont : labeler_viewer_state Jsont.t
-
-
-type labeler_policies = {
-  label_value_definitions : Com.Atproto.Label.Defs.label_value_definition list option;  (** Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler. *)
-  label_values : Com.Atproto.Label.Defs.label_value list;  (** The label values which this labeler publishes. May include global or custom labels. *)
-}
-
-(** Jsont codec for {!type:labeler_policies}. *)
-val labeler_policies_jsont : labeler_policies Jsont.t
-
-
-type labeler_view_detailed = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  policies : Jsont.json;
-  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;  (** The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed. *)
-  subject_collections : string list option;  (** Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type. *)
-  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-(** Jsont codec for {!type:labeler_view_detailed}. *)
-val labeler_view_detailed_jsont : labeler_view_detailed Jsont.t
-
-
-type labeler_view = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-(** Jsont codec for {!type:labeler_view}. *)
-val labeler_view_jsont : labeler_view Jsont.t
-
-      end
-      module Service : sig
-(** A declaration of the existence of labeler service. *)
-
-type main = {
-  created_at : string;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  policies : Jsont.json;
-  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;  (** The set of report reason 'codes' which are in-scope for this service to review and action. These usually align to policy categories. If not defined (distinct from empty array), all reason types are allowed. *)
-  subject_collections : string list option;  (** Set of record types (collection NSIDs) which can be reported to this service. If not defined (distinct from empty array), default is any record type. *)
-  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module GetServices : sig
-(** Get information about a list of labeler services. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  detailed : bool option;
-  dids : string list;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  views : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-    end
     module Actor : sig
       module Status : sig
 (** Advertises an account as currently offering live content. *)
···
   duration_minutes : int option;  (** The duration of the status in minutes. Applications can choose to impose minimum and maximum limits. *)
   embed : Jsont.json option;  (** An optional embed associated with the status. *)
   status : string;  (** The status for the account. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module Profile : sig
+(** A declaration of a Bluesky account profile. *)
+
+type main = {
+  avatar : Atp.Blob_ref.t option;  (** Small image to be displayed next to posts from account. AKA, 'profile picture' *)
+  banner : Atp.Blob_ref.t option;  (** Larger horizontal image to display behind profile view. *)
+  created_at : string option;
+  description : string option;  (** Free-form profile description text. *)
+  display_name : string option;
+  joined_via_starter_pack : Com.Atproto.Repo.StrongRef.main option;
+  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values, specific to the Bluesky application, on the overall account. *)
+  pinned_post : Com.Atproto.Repo.StrongRef.main option;
+  pronouns : string option;  (** Free-form pronouns text. *)
+  website : string option;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 val known_followers_jsont : known_followers Jsont.t
 
       end
-      module Profile : sig
-(** A declaration of a Bluesky account profile. *)
+      module GetPreferences : sig
+(** Get private preferences attached to the current account. Expected use is synchronization between multiple devices, and import/export during account migration. Requires auth. *)
+
+(** Query/procedure parameters. *)
+type params = unit
+
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
+
 
-type main = {
-  avatar : Atp.Blob_ref.t option;  (** Small image to be displayed next to posts from account. AKA, 'profile picture' *)
-  banner : Atp.Blob_ref.t option;  (** Larger horizontal image to display behind profile view. *)
-  created_at : string option;
-  description : string option;  (** Free-form profile description text. *)
-  display_name : string option;
-  joined_via_starter_pack : Com.Atproto.Repo.StrongRef.main option;
-  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values, specific to the Bluesky application, on the overall account. *)
-  pinned_post : Com.Atproto.Repo.StrongRef.main option;
-  pronouns : string option;  (** Free-form pronouns text. *)
-  website : string option;
+type output = {
+  preferences : Jsont.json;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-      module GetProfiles : sig
-(** Get detailed profile views of multiple actors. *)
+      module SearchActorsTypeahead : sig
+(** Find actor suggestions for a prefix search term. Expected use is for auto-completion during text field entry. Does not require auth. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actors : string list;
+  limit : int option;
+  q : string option;  (** Search query prefix; not a full query string. *)
+  term : string option;  (** DEPRECATED: use 'q' instead. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  profiles : Jsont.json list;
+  actors : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetPreferences : sig
-(** Get private preferences attached to the current account. Expected use is synchronization between multiple devices, and import/export during account migration. Requires auth. *)
+      module GetProfile : sig
+(** Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth. *)
 
 (** Query/procedure parameters. *)
-type params = unit
+type params = {
+  actor : string;  (** Handle or DID of account to fetch profile of. *)
+}
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
 
-type output = {
-  preferences : Jsont.json;
-}
+type output = Jsont.json
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestions : sig
-(** Get a list of suggested actors. Expected use is discovery of accounts to follow during new account onboarding. *)
+      module SearchActors : sig
+(** Find actors (profiles) matching search criteria. Does not require auth. *)
 
 (** Query/procedure parameters. *)
 type params = {
   cursor : string option;
   limit : int option;
+  q : string option;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
+  term : string option;  (** DEPRECATED: use 'q' instead. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 type output = {
   actors : Jsont.json list;
   cursor : string option;
-  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetProfile : sig
-(** Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth. *)
+      module GetSuggestions : sig
+(** Get a list of suggested actors. Expected use is discovery of accounts to follow during new account onboarding. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;  (** Handle or DID of account to fetch profile of. *)
+  cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
 
-type output = Jsont.json
+type output = {
+  actors : Jsont.json list;
+  cursor : string option;
+  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
+}
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module SearchActors : sig
-(** Find actors (profiles) matching search criteria. Does not require auth. *)
+      module GetProfiles : sig
+(** Get detailed profile views of multiple actors. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;
-  limit : int option;
-  q : string option;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
-  term : string option;  (** DEPRECATED: use 'q' instead. *)
+  actors : string list;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  actors : Jsont.json list;
-  cursor : string option;
+  profiles : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val input_jsont : input Jsont.t
 
       end
-      module SearchActorsTypeahead : sig
-(** Find actor suggestions for a prefix search term. Expected use is for auto-completion during text field entry. Does not require auth. *)
+    end
+    module Contact : sig
+      module Defs : sig
 
-(** Query/procedure parameters. *)
-type params = {
-  limit : int option;
-  q : string option;  (** Search query prefix; not a full query string. *)
-  term : string option;  (** DEPRECATED: use 'q' instead. *)
+type sync_status = {
+  matches_count : int;  (** Number of existing contact matches resulting of the user imports and of their imported contacts having imported the user. Matches stop being counted when the user either follows the matched contact or dismisses the match. *)
+  synced_at : string;  (** Last date when contacts where imported. *)
+}
+
+(** Jsont codec for {!type:sync_status}. *)
+val sync_status_jsont : sync_status Jsont.t
+
+(** A stash object to be sent via bsync representing a notification to be created. *)
+
+type notification = {
+  from : string;  (** The DID of who this notification comes from. *)
+  to_ : string;  (** The DID of who this notification should go to. *)
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:notification}. *)
+val notification_jsont : notification Jsont.t
 
+(** Associates a profile with the positional index of the contact import input in the call to `app.bsky.contact.importContacts`, so clients can know which phone caused a particular match. *)
 
-type output = {
-  actors : Jsont.json list;
+type match_and_contact_index = {
+  contact_index : int;  (** The index of this match in the import contact input. *)
+  match_ : Jsont.json;  (** Profile of the matched user. *)
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:match_and_contact_index}. *)
+val match_and_contact_index_jsont : match_and_contact_index Jsont.t
 
       end
-    end
-    module Video : sig
-      module GetUploadLimits : sig
-(** Get video upload limits for the authenticated user. *)
+      module RemoveData : sig
+(** Removes all stored hashes used for contact matching, existing matches, and sync status. Requires authentication. *)
 
 
-type output = {
-  can_upload : bool;
-  error : string option;
-  message : string option;
-  remaining_daily_bytes : int option;
-  remaining_daily_videos : int option;
-}
+type input = unit
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+
+type output = unit
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Defs : sig
+      module DismissMatch : sig
+(** Removes a match that was found via contact import. It shouldn't appear again if the same contact is re-imported. Requires authentication. *)
 
-type job_status = {
-  blob : Atp.Blob_ref.t option;
-  did : string;
-  error : string option;
-  job_id : string;
-  message : string option;
-  progress : int option;  (** Progress within the current processing state. *)
-  state : string;  (** The state of the video processing job. All values not listed as a known value indicate that the job is in process. *)
+
+type input = {
+  subject : string;  (** The subject's DID to dismiss the match with. *)
 }
 
-(** Jsont codec for {!type:job_status}. *)
-val job_status_jsont : job_status Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+
+type output = unit
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-      module GetJobStatus : sig
-(** Get status details for a video processing job. *)
+      module GetMatches : sig
+(** Returns the matched contacts (contacts that were mutually imported). Excludes dismissed matches. Requires authentication. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  job_id : string;
+  cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  job_status : Defs.job_status;
+  cursor : string option;
+  matches : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module UploadVideo : sig
-(** Upload a video to be processed then stored on the PDS. *)
+      module VerifyPhone : sig
+(** Verifies control over a phone number with a code received via SMS and starts a contact import session. Requires authentication. *)
+
 
+type input = {
+  code : string;  (** The code received via SMS as a result of the call to `app.bsky.contact.startPhoneVerification`. *)
+  phone : string;  (** The phone number to verify. Should be the same as the one passed to `app.bsky.contact.startPhoneVerification`. *)
+}
 
-type input = unit
+(** Jsont codec for {!type:input}. *)
 val input_jsont : input Jsont.t
 
 
 type output = {
-  job_status : Defs.job_status;
+  token : string;  (** JWT to be used in a call to `app.bsky.contact.importContacts`. It is only valid for a single call. *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-    end
-    module Richtext : sig
-      module Facet : sig
-(** Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags'). *)
+      module StartPhoneVerification : sig
+(** Starts a phone verification flow. The phone passed will receive a code via SMS that should be passed to `app.bsky.contact.verifyPhone`. Requires authentication. *)
+
 
-type tag = {
-  tag : string;
+type input = {
+  phone : string;  (** The phone number to receive the code via SMS. *)
 }
 
-(** Jsont codec for {!type:tag}. *)
-val tag_jsont : tag Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-(** Facet feature for mention of another account. The text is usually a handle, including a '\@' prefix, but the facet reference is a DID. *)
 
-type mention = {
-  did : string;
-}
+type output = unit
 
-(** Jsont codec for {!type:mention}. *)
-val mention_jsont : mention Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL. *)
+      end
+      module SendNotification : sig
+(** System endpoint to send notifications related to contact imports. Requires role authentication. *)
 
-type link = {
-  uri : string;
-}
 
-(** Jsont codec for {!type:link}. *)
-val link_jsont : link Jsont.t
-
-(** Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets. *)
-
-type byte_slice = {
-  byte_end : int;
-  byte_start : int;
+type input = {
+  from : string;  (** The DID of who this notification comes from. *)
+  to_ : string;  (** The DID of who this notification should go to. *)
 }
 
-(** Jsont codec for {!type:byte_slice}. *)
-val byte_slice_jsont : byte_slice Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-(** Annotation of a sub-string within rich text. *)
 
-type main = {
-  features : Jsont.json list;
-  index : byte_slice;
-}
+type output = unit
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-    end
-    module AuthCreatePosts : sig
+      module GetSyncStatus : sig
+(** Gets the user's current contact import status. Requires authentication. *)
 
-type main = unit
-val main_jsont : main Jsont.t
+(** Query/procedure parameters. *)
+type params = unit
 
-    end
-    module Ageassurance : sig
-      module Defs : sig
-(** The status of the Age Assurance process. *)
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-type status = string
-val status_jsont : status Jsont.t
 
-(** Additional metadata needed to compute Age Assurance state client-side. *)
-
-type state_metadata = {
-  account_created_at : string option;  (** The account creation timestamp. *)
+type output = {
+  sync_status : Defs.sync_status option;  (** If present, indicates the user has imported their contacts. If not present, indicates the user never used the feature or called `app.bsky.contact.removeData` and didn't import again since. *)
 }
 
-(** Jsont codec for {!type:state_metadata}. *)
-val state_metadata_jsont : state_metadata Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** Object used to store Age Assurance data in stash. *)
+      end
+      module ImportContacts : sig
+(** Import contacts for securely matching with other users. This follows the protocol explained in https://docs.bsky.app/blog/contact-import-rfc. Requires authentication. *)
 
-type event = {
-  access : string;  (** The access level granted based on Age Assurance data we've processed. *)
-  attempt_id : string;  (** The unique identifier for this instance of the Age Assurance flow, in UUID format. *)
-  complete_ip : string option;  (** The IP address used when completing the Age Assurance flow. *)
-  complete_ua : string option;  (** The user agent used when completing the Age Assurance flow. *)
-  country_code : string;  (** The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow. *)
-  created_at : string;  (** The date and time of this write operation. *)
-  email : string option;  (** The email used for Age Assurance. *)
-  init_ip : string option;  (** The IP address used when initiating the Age Assurance flow. *)
-  init_ua : string option;  (** The user agent used when initiating the Age Assurance flow. *)
-  region_code : string option;  (** The ISO 3166-2 region code provided when beginning the Age Assurance flow. *)
-  status : string;  (** The status of the Age Assurance process. *)
+
+type input = {
+  contacts : string list;  (** List of phone numbers in global E.164 format (e.g., '[phone]'). Phone numbers that cannot be normalized into a valid phone number will be discarded. Should not repeat the 'phone' input used in `app.bsky.contact.verifyPhone`. *)
+  token : string;  (** JWT to authenticate the call. Use the JWT received as a response to the call to `app.bsky.contact.verifyPhone`. *)
 }
 
-(** Jsont codec for {!type:event}. *)
-val event_jsont : event Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-(** The Age Assurance configuration for a specific region. *)
 
-type config_region = {
-  country_code : string;  (** The ISO 3166-1 alpha-2 country code this configuration applies to. *)
-  min_access_age : int;  (** The minimum age (as a whole integer) required to use Bluesky in this region. *)
-  region_code : string option;  (** The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country. *)
-  rules : Jsont.json list;  (** The ordered list of Age Assurance rules that apply to this region. Rules should be applied in order, and the first matching rule determines the access level granted. The rules array should always include a default rule as the last item. *)
+type output = {
+  matches_and_contact_indexes : Defs.match_and_contact_index list;  (** The users that matched during import and their indexes on the input contacts, so the client can correlate with its local list. *)
 }
 
-(** Jsont codec for {!type:config_region}. *)
-val config_region_jsont : config_region Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** The access level granted based on Age Assurance data we've processed. *)
+      end
+    end
+    module Graph : sig
+      module Starterpack : sig
 
-type access = string
-val access_jsont : access Jsont.t
-
-(** The user's computed Age Assurance state. *)
-
-type state = {
-  access : access;
-  last_initiated_at : string option;  (** The timestamp when this state was last updated. *)
-  status : status;
+type feed_item = {
+  uri : string;
 }
 
-(** Jsont codec for {!type:state}. *)
-val state_jsont : state Jsont.t
+(** Jsont codec for {!type:feed_item}. *)
+val feed_item_jsont : feed_item Jsont.t
 
-(** Age Assurance rule that applies if the user has declared themselves under a certain age. *)
+(** Record defining a starter pack of actors and feeds for new users. *)
 
-type config_region_rule_if_declared_under_age = {
-  access : access;
-  age : int;  (** The age threshold as a whole integer. *)
+type main = {
+  created_at : string;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  feeds : Jsont.json list option;
+  list_ : string;  (** Reference (AT-URI) to the list record. *)
+  name : string;  (** Display name for starter pack; can not be empty. *)
 }
 
-(** Jsont codec for {!type:config_region_rule_if_declared_under_age}. *)
-val config_region_rule_if_declared_under_age_jsont : config_region_rule_if_declared_under_age Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-(** Age Assurance rule that applies if the user has declared themselves equal-to or over a certain age. *)
+      end
+      module GetFollows : sig
+(** Enumerates accounts which a specified account (actor) follows. *)
 
-type config_region_rule_if_declared_over_age = {
-  access : access;
-  age : int;  (** The age threshold as a whole integer. *)
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:config_region_rule_if_declared_over_age}. *)
-val config_region_rule_if_declared_over_age_jsont : config_region_rule_if_declared_over_age Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-(** Age Assurance rule that applies if the user has been assured to be under a certain age. *)
 
-type config_region_rule_if_assured_under_age = {
-  access : access;
-  age : int;  (** The age threshold as a whole integer. *)
+type output = {
+  cursor : string option;
+  follows : Jsont.json list;
+  subject : Jsont.json;
 }
 
-(** Jsont codec for {!type:config_region_rule_if_assured_under_age}. *)
-val config_region_rule_if_assured_under_age_jsont : config_region_rule_if_assured_under_age Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** Age Assurance rule that applies if the user has been assured to be equal-to or over a certain age. *)
+      end
+      module GetSuggestedFollowsByActor : sig
+(** Enumerates follows similar to a given account (actor). Expected use is to recommend additional accounts immediately after following one account. *)
 
-type config_region_rule_if_assured_over_age = {
-  access : access;
-  age : int;  (** The age threshold as a whole integer. *)
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;
 }
 
-(** Jsont codec for {!type:config_region_rule_if_assured_over_age}. *)
-val config_region_rule_if_assured_over_age_jsont : config_region_rule_if_assured_over_age Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-(** Age Assurance rule that applies if the account is older than a certain date. *)
 
-type config_region_rule_if_account_older_than = {
-  access : access;
-  date : string;  (** The date threshold as a datetime string. *)
+type output = {
+  is_fallback : bool option;  (** If true, response has fallen-back to generic results, and is not scoped using relativeToDid *)
+  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
+  suggestions : Jsont.json list;
 }
 
-(** Jsont codec for {!type:config_region_rule_if_account_older_than}. *)
-val config_region_rule_if_account_older_than_jsont : config_region_rule_if_account_older_than Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** Age Assurance rule that applies if the account is equal-to or newer than a certain date. *)
+      end
+      module Block : sig
+(** Record declaring a 'block' relationship against another account. NOTE: blocks are public in Bluesky; see blog posts for details. *)
 
-type config_region_rule_if_account_newer_than = {
-  access : access;
-  date : string;  (** The date threshold as a datetime string. *)
+type main = {
+  created_at : string;
+  subject : string;  (** DID of the account to be blocked. *)
 }
 
-(** Jsont codec for {!type:config_region_rule_if_account_newer_than}. *)
-val config_region_rule_if_account_newer_than_jsont : config_region_rule_if_account_newer_than Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-(** Age Assurance rule that applies by default. *)
+      end
+      module Listblock : sig
+(** Record representing a block relationship against an entire an entire list of accounts (actors). *)
 
-type config_region_rule_default = {
-  access : access;
+type main = {
+  created_at : string;
+  subject : string;  (** Reference (AT-URI) to the mod list record. *)
 }
 
-(** Jsont codec for {!type:config_region_rule_default}. *)
-val config_region_rule_default_jsont : config_region_rule_default Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module MuteThread : sig
+(** Mutes a thread preventing notifications from the thread and any of its children. Mutes are private in Bluesky. Requires auth. *)
 
 
-type config = {
-  regions : config_region list;  (** The per-region Age Assurance configuration. *)
+type input = {
+  root : string;
 }
 
-(** Jsont codec for {!type:config}. *)
-val config_jsont : config Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-      module GetState : sig
-(** Returns server-computed Age Assurance state, if available, and any additional metadata needed to compute Age Assurance state client-side. *)
+      module GetFollowers : sig
+(** Enumerates accounts which follow a specified account (actor). *)
 
 (** Query/procedure parameters. *)
 type params = {
-  country_code : string;
-  region_code : string option;
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  metadata : Defs.state_metadata;
-  state : Defs.state;
+  cursor : string option;
+  followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Begin : sig
-(** Initiate Age Assurance for an account. *)
+      module UnmuteThread : sig
+(** Unmutes the specified thread. Requires auth. *)
 
 
 type input = {
-  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
-  email : string;  (** The user's email address to receive Age Assurance instructions. *)
-  language : string;  (** The user's preferred language for communication during the Age Assurance process. *)
-  region_code : string option;  (** An optional ISO 3166-2 code of the user's region or state within the country. *)
+  root : string;
 }
 
 (** Jsont codec for {!type:input}. *)
 val input_jsont : input Jsont.t
 
+      end
+      module Follow : sig
+(** Record declaring a social 'follow' relationship of another account. Duplicate follows will be ignored by the AppView. *)
 
-type output = Defs.state
+type main = {
+  created_at : string;
+  subject : string;
+  via : Com.Atproto.Repo.StrongRef.main option;
+}
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
-      module GetConfig : sig
-(** Returns Age Assurance configuration for use on the client. *)
+      module UnmuteActor : sig
+(** Unmutes the specified account. Requires auth. *)
 
 
-type output = Defs.config
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-    end
-    module Embed : sig
-      module Defs : sig
-(** width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit. *)
-
-type aspect_ratio = {
-  height : int;
-  width : int;
+type input = {
+  actor : string;
 }
 
-(** Jsont codec for {!type:aspect_ratio}. *)
-val aspect_ratio_jsont : aspect_ratio Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-      module External : sig
-
-type view_external = {
-  description : string;
-  thumb : string option;
-  title : string;
-  uri : string;
-}
-
-(** Jsont codec for {!type:view_external}. *)
-val view_external_jsont : view_external Jsont.t
+      module MuteActorList : sig
+(** Creates a mute relationship for the specified list of accounts. Mutes are private in Bluesky. Requires auth. *)
 
 
-type external_ = {
-  description : string;
-  thumb : Atp.Blob_ref.t option;
-  title : string;
-  uri : string;
+type input = {
+  list_ : string;
 }
 
-(** Jsont codec for {!type:external_}. *)
-val external__jsont : external_ Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
+      end
+      module UnmuteActorList : sig
+(** Unmutes the specified list of accounts. Requires auth. *)
 
-type view = {
-  external_ : Jsont.json;
-}
 
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
-
-(** A representation of some externally linked content (eg, a URL and 'card'), embedded in a Bluesky record (eg, a post). *)
-
-type main = {
-  external_ : Jsont.json;
+type input = {
+  list_ : string;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-      module Images : sig
+      module GetKnownFollowers : sig
+(** Enumerates accounts which follow a specified account (actor) and are followed by the viewer. *)
 
-type view_image = {
-  alt : string;  (** Alt text description of the image, for accessibility. *)
-  aspect_ratio : Jsont.json option;
-  fullsize : string;  (** Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View. *)
-  thumb : string;  (** Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View. *)
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:view_image}. *)
-val view_image_jsont : view_image Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type image = {
-  alt : string;  (** Alt text description of the image, for accessibility. *)
-  aspect_ratio : Jsont.json option;
-  image : Atp.Blob_ref.t;
+type output = {
+  cursor : string option;
+  followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
-(** Jsont codec for {!type:image}. *)
-val image_jsont : image Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
+      end
+      module MuteActor : sig
+(** Creates a mute relationship for the specified account. Mutes are private in Bluesky. Requires auth. *)
 
-type view = {
-  images : Jsont.json list;
+
+type input = {
+  actor : string;
 }
 
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
+      end
+      module Listitem : sig
+(** Record representing an account's inclusion on a specific list. The AppView will ignore duplicate listitem records. *)
 
 type main = {
-  images : Jsont.json list;
+  created_at : string;
+  list_ : string;  (** Reference (AT-URI) to the list record (app.bsky.graph.list). *)
+  subject : string;  (** The account which is included on the list. *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
       end
-      module Video : sig
+      module Defs : sig
 
-type view = {
-  alt : string option;
-  aspect_ratio : Jsont.json option;
+type starter_pack_view_basic = {
   cid : string;
-  playlist : string;
-  thumbnail : string option;
+  creator : Jsont.json;
+  indexed_at : string;
+  joined_all_time_count : int option;
+  joined_week_count : int option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_item_count : int option;
+  record : Jsont.json;
+  uri : string;
 }
 
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
+(** Jsont codec for {!type:starter_pack_view_basic}. *)
+val starter_pack_view_basic_jsont : starter_pack_view_basic Jsont.t
 
+(** lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object) *)
 
-type caption = {
-  file : Atp.Blob_ref.t;
-  lang : string;
+type relationship = {
+  blocked_by : string option;  (** if the actor is blocked by this DID, contains the AT-URI of the block record *)
+  blocked_by_list : string option;  (** if the actor is blocked by this DID via a block list, contains the AT-URI of the listblock record *)
+  blocking : string option;  (** if the actor blocks this DID, this is the AT-URI of the block record *)
+  blocking_by_list : string option;  (** if the actor blocks this DID via a block list, this is the AT-URI of the listblock record *)
+  did : string;
+  followed_by : string option;  (** if the actor is followed by this DID, contains the AT-URI of the follow record *)
+  following : string option;  (** if the actor follows this DID, this is the AT-URI of the follow record *)
 }
 
-(** Jsont codec for {!type:caption}. *)
-val caption_jsont : caption Jsont.t
+(** Jsont codec for {!type:relationship}. *)
+val relationship_jsont : relationship Jsont.t
 
+(** A list of actors used for only for reference purposes such as within a starter pack. *)
 
-type main = {
-  alt : string option;  (** Alt text description of the video, for accessibility. *)
-  aspect_ratio : Jsont.json option;
-  captions : Jsont.json list option;
-  video : Atp.Blob_ref.t;  (** The mp4 video file. May be up to 100mb, formerly limited to 50mb. *)
+type referencelist = string
+val referencelist_jsont : referencelist Jsont.t
+
+(** indicates that a handle or DID could not be resolved *)
+
+type not_found_actor = {
+  actor : string;
+  not_found : bool;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:not_found_actor}. *)
+val not_found_actor_jsont : not_found_actor Jsont.t
+
+(** A list of actors to apply an aggregate moderation action (mute/block) on. *)
+
+type modlist = string
+val modlist_jsont : modlist Jsont.t
 
-      end
-      module RecordWithMedia : sig
 
-type view = {
-  media : Jsont.json;
-  record : Jsont.json;
+type list_viewer_state = {
+  blocked : string option;
+  muted : bool option;
 }
 
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
+(** Jsont codec for {!type:list_viewer_state}. *)
+val list_viewer_state_jsont : list_viewer_state Jsont.t
 
 
-type main = {
-  media : Jsont.json;
-  record : Jsont.json;
+type list_purpose = string
+val list_purpose_jsont : list_purpose Jsont.t
+
+
+type list_item_view = {
+  subject : Jsont.json;
+  uri : string;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:list_item_view}. *)
+val list_item_view_jsont : list_item_view Jsont.t
+
+(** A list of actors used for curation purposes such as list feeds or interaction gating. *)
+
+type curatelist = string
+val curatelist_jsont : curatelist Jsont.t
 
-      end
-      module Record : sig
 
-type view_record = {
-  author : Jsont.json;
+type list_view_basic = {
+  avatar : string option;
   cid : string;
-  embeds : Jsont.json list option;
-  indexed_at : string;
+  indexed_at : string option;
   labels : Com.Atproto.Label.Defs.label list option;
-  like_count : int option;
-  quote_count : int option;
-  reply_count : int option;
-  repost_count : int option;
+  list_item_count : int option;
+  name : string;
+  purpose : Jsont.json;
   uri : string;
-  value : Jsont.json;  (** The record data itself. *)
+  viewer : Jsont.json option;
 }
 
-(** Jsont codec for {!type:view_record}. *)
-val view_record_jsont : view_record Jsont.t
+(** Jsont codec for {!type:list_view_basic}. *)
+val list_view_basic_jsont : list_view_basic Jsont.t
 
 
-type view_not_found = {
-  not_found : bool;
+type list_view = {
+  avatar : string option;
+  cid : string;
+  creator : Jsont.json;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_item_count : int option;
+  name : string;
+  purpose : Jsont.json;
   uri : string;
+  viewer : Jsont.json option;
 }
 
-(** Jsont codec for {!type:view_not_found}. *)
-val view_not_found_jsont : view_not_found Jsont.t
+(** Jsont codec for {!type:list_view}. *)
+val list_view_jsont : list_view Jsont.t
 
 
-type view_detached = {
-  detached : bool;
+type starter_pack_view = {
+  cid : string;
+  creator : Jsont.json;
+  feeds : Jsont.json list option;
+  indexed_at : string;
+  joined_all_time_count : int option;
+  joined_week_count : int option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  list_ : Jsont.json option;
+  list_items_sample : Jsont.json list option;
+  record : Jsont.json;
   uri : string;
 }
 
-(** Jsont codec for {!type:view_detached}. *)
-val view_detached_jsont : view_detached Jsont.t
+(** Jsont codec for {!type:starter_pack_view}. *)
+val starter_pack_view_jsont : starter_pack_view Jsont.t
 
+      end
+      module GetBlocks : sig
+(** Enumerates which accounts the requesting account is currently blocking. Requires auth. *)
 
-type view_blocked = {
-  author : Jsont.json;
-  blocked : bool;
-  uri : string;
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:view_blocked}. *)
-val view_blocked_jsont : view_blocked Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type view = {
-  record : Jsont.json;
+type output = {
+  blocks : Jsont.json list;
+  cursor : string option;
 }
 
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
+      end
+      module Verification : sig
+(** Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted. *)
 
 type main = {
-  record : Com.Atproto.Repo.StrongRef.main;
+  created_at : string;  (** Date of when the verification was created. *)
+  display_name : string;  (** Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying. *)
+  handle : string;  (** Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying. *)
+  subject : string;  (** DID of the subject the verification applies to. *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
       end
-    end
-    module Contact : sig
-      module SendNotification : sig
-(** System endpoint to send notifications related to contact imports. Requires role authentication. *)
+      module GetMutes : sig
+(** Enumerates accounts that the requesting account (actor) currently has muted. Requires auth. *)
 
-
-type input = {
-  from : string;  (** The DID of who this notification comes from. *)
-  to_ : string;  (** The DID of who this notification should go to. *)
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type output = unit
+type output = {
+  cursor : string option;
+  mutes : Jsont.json list;
+}
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module StartPhoneVerification : sig
-(** Starts a phone verification flow. The phone passed will receive a code via SMS that should be passed to `app.bsky.contact.verifyPhone`. Requires authentication. *)
+      module GetRelationships : sig
+(** Enumerates public relationships between one account, and a list of other accounts. Does not require auth. *)
 
-
-type input = {
-  phone : string;  (** The phone number to receive the code via SMS. *)
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;  (** Primary account requesting relationships for. *)
+  others : string list option;  (** List of 'other' accounts to be related back to the primary. *)
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type output = unit
+type output = {
+  actor : string option;
+  relationships : Jsont.json list;
+}
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetMatches : sig
-(** Returns the matched contacts (contacts that were mutually imported). Excludes dismissed matches. Requires authentication. *)
+      module GetStarterPacksWithMembership : sig
+(** A starter pack and an optional list item indicating membership of a target user to that starter pack. *)
+
+type starter_pack_with_membership = {
+  list_item : Jsont.json option;
+  starter_pack : Jsont.json;
+}
+
+(** Jsont codec for {!type:starter_pack_with_membership}. *)
+val starter_pack_with_membership_jsont : starter_pack_with_membership Jsont.t
+
+(** Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth. *)
 
 (** Query/procedure parameters. *)
 type params = {
+  actor : string;  (** The account (actor) to check for membership. *)
   cursor : string option;
   limit : int option;
 }
···
 
 type output = {
   cursor : string option;
-  matches : Jsont.json list;
+  starter_packs_with_membership : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module VerifyPhone : sig
-(** Verifies control over a phone number with a code received via SMS and starts a contact import session. Requires authentication. *)
+      module GetActorStarterPacks : sig
+(** Get a list of starter packs created by the actor. *)
 
-
-type input = {
-  code : string;  (** The code received via SMS as a result of the call to `app.bsky.contact.startPhoneVerification`. *)
-  phone : string;  (** The phone number to verify. Should be the same as the one passed to `app.bsky.contact.startPhoneVerification`. *)
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
 type output = {
-  token : string;  (** JWT to be used in a call to `app.bsky.contact.importContacts`. It is only valid for a single call. *)
+  cursor : string option;
+  starter_packs : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module RemoveData : sig
-(** Removes all stored hashes used for contact matching, existing matches, and sync status. Requires authentication. *)
-
+      module List : sig
+(** Record representing a list of accounts (actors). Scope includes both moderation-oriented lists and curration-oriented lists. *)
 
-type input = unit
+type main = {
+  avatar : Atp.Blob_ref.t option;
+  created_at : string;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  labels : Com.Atproto.Label.Defs.self_labels option;
+  name : string;  (** Display name for list; can not be empty. *)
+  purpose : Jsont.json;  (** Defines the purpose of the list (aka, moderation-oriented or curration-oriented) *)
+}
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+      end
+      module SearchStarterPacks : sig
+(** Find starter packs matching search criteria. Does not require auth. *)
 
-type output = unit
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
+  q : string;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
+}
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-      end
-      module Defs : sig
 
-type sync_status = {
-  matches_count : int;  (** Number of existing contact matches resulting of the user imports and of their imported contacts having imported the user. Matches stop being counted when the user either follows the matched contact or dismisses the match. *)
-  synced_at : string;  (** Last date when contacts where imported. *)
+type output = {
+  cursor : string option;
+  starter_packs : Jsont.json list;
 }
 
-(** Jsont codec for {!type:sync_status}. *)
-val sync_status_jsont : sync_status Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** A stash object to be sent via bsync representing a notification to be created. *)
+      end
+      module GetList : sig
+(** Gets a 'view' (with additional context) of a specified list. *)
 
-type notification = {
-  from : string;  (** The DID of who this notification comes from. *)
-  to_ : string;  (** The DID of who this notification should go to. *)
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
+  list_ : string;  (** Reference (AT-URI) of the list record to hydrate. *)
 }
 
-(** Jsont codec for {!type:notification}. *)
-val notification_jsont : notification Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-(** Associates a profile with the positional index of the contact import input in the call to `app.bsky.contact.importContacts`, so clients can know which phone caused a particular match. *)
 
-type match_and_contact_index = {
-  contact_index : int;  (** The index of this match in the import contact input. *)
-  match_ : Jsont.json;  (** Profile of the matched user. *)
+type output = {
+  cursor : string option;
+  items : Jsont.json list;
+  list_ : Jsont.json;
 }
 
-(** Jsont codec for {!type:match_and_contact_index}. *)
-val match_and_contact_index_jsont : match_and_contact_index Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-      module DismissMatch : sig
-(** Removes a match that was found via contact import. It shouldn't appear again if the same contact is re-imported. Requires authentication. *)
+      module GetListBlocks : sig
+(** Get mod lists that the requesting account (actor) is blocking. Requires auth. *)
 
-
-type input = {
-  subject : string;  (** The subject's DID to dismiss the match with. *)
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type output = unit
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
+}
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetSyncStatus : sig
-(** Gets the user's current contact import status. Requires authentication. *)
+      module GetStarterPack : sig
+(** Gets a view of a starter pack. *)
 
 (** Query/procedure parameters. *)
-type params = unit
+type params = {
+  starter_pack : string;  (** Reference (AT-URI) of the starter pack record. *)
+}
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
 
 type output = {
-  sync_status : Defs.sync_status option;  (** If present, indicates the user has imported their contacts. If not present, indicates the user never used the feature or called `app.bsky.contact.removeData` and didn't import again since. *)
+  starter_pack : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module ImportContacts : sig
-(** Import contacts for securely matching with other users. This follows the protocol explained in https://docs.bsky.app/blog/contact-import-rfc. Requires authentication. *)
+      module GetListsWithMembership : sig
+(** A list and an optional list item indicating membership of a target user to that list. *)
+
+type list_with_membership = {
+  list_ : Jsont.json;
+  list_item : Jsont.json option;
+}
 
+(** Jsont codec for {!type:list_with_membership}. *)
+val list_with_membership_jsont : list_with_membership Jsont.t
 
-type input = {
-  contacts : string list;  (** List of phone numbers in global E.164 format (e.g., '[phone]'). Phone numbers that cannot be normalized into a valid phone number will be discarded. Should not repeat the 'phone' input used in `app.bsky.contact.verifyPhone`. *)
-  token : string;  (** JWT to authenticate the call. Use the JWT received as a response to the call to `app.bsky.contact.verifyPhone`. *)
+(** Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth. *)
+
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;  (** The account (actor) to check for membership. *)
+  cursor : string option;
+  limit : int option;
+  purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
 type output = {
-  matches_and_contact_indexes : Defs.match_and_contact_index list;  (** The users that matched during import and their indexes on the input contacts, so the client can correlate with its local list. *)
+  cursor : string option;
+  lists_with_membership : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-    end
-    module Feed : sig
-      module Repost : sig
-(** Record representing a 'repost' of an existing Bluesky post. *)
+      module GetListMutes : sig
+(** Enumerates mod lists that the requesting account (actor) currently has muted. Requires auth. *)
 
-type main = {
-  created_at : string;
-  subject : Com.Atproto.Repo.StrongRef.main;
-  via : Com.Atproto.Repo.StrongRef.main option;
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;
+  limit : int option;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-      end
-      module DescribeFeedGenerator : sig
 
-type links = {
-  privacy_policy : string option;
-  terms_of_service : string option;
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
 }
 
-(** Jsont codec for {!type:links}. *)
-val links_jsont : links Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
+      end
+      module GetStarterPacks : sig
+(** Get views for a list of starter packs. *)
 
-type feed = {
-  uri : string;
+(** Query/procedure parameters. *)
+type params = {
+  uris : string list;
 }
 
-(** Jsont codec for {!type:feed}. *)
-val feed_jsont : feed Jsont.t
-
-(** Get information about a feed generator, including policies and offered feed URIs. Does not require auth; implemented by Feed Generator services (not App View). *)
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
 type output = {
-  did : string;
-  feeds : Jsont.json list;
-  links : Jsont.json option;
+  starter_packs : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Threadgate : sig
-(** Allow replies from actors mentioned in your post. *)
+      module GetLists : sig
+(** Enumerates the lists created by a specified account (actor). *)
 
-type mention_rule = unit
+(** Query/procedure parameters. *)
+type params = {
+  actor : string;  (** The account (actor) to enumerate lists from. *)
+  cursor : string option;
+  limit : int option;
+  purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
+}
 
-(** Jsont codec for {!type:mention_rule}. *)
-val mention_rule_jsont : mention_rule Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-(** Allow replies from actors on a list. *)
 
-type list_rule = {
-  list_ : string;
+type output = {
+  cursor : string option;
+  lists : Jsont.json list;
 }
 
-(** Jsont codec for {!type:list_rule}. *)
-val list_rule_jsont : list_rule Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** Allow replies from actors you follow. *)
+      end
+    end
+    module Feed : sig
+      module Post : sig
+(** Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings. *)
 
-type following_rule = unit
+type text_slice = {
+  end_ : int;
+  start : int;
+}
 
-(** Jsont codec for {!type:following_rule}. *)
-val following_rule_jsont : following_rule Jsont.t
+(** Jsont codec for {!type:text_slice}. *)
+val text_slice_jsont : text_slice Jsont.t
 
-(** Allow replies from actors who follow you. *)
 
-type follower_rule = unit
+type reply_ref = {
+  parent : Com.Atproto.Repo.StrongRef.main;
+  root : Com.Atproto.Repo.StrongRef.main;
+}
 
-(** Jsont codec for {!type:follower_rule}. *)
-val follower_rule_jsont : follower_rule Jsont.t
+(** Jsont codec for {!type:reply_ref}. *)
+val reply_ref_jsont : reply_ref Jsont.t
 
-(** Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository. *)
+(** Deprecated: use facets instead. *)
 
-type main = {
-  allow : Jsont.json list option;  (** List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply. *)
-  created_at : string;
-  hidden_replies : string list option;  (** List of hidden reply URIs. *)
-  post : string;  (** Reference (AT-URI) to the post record. *)
+type entity = {
+  index : Jsont.json;
+  type_ : string;  (** Expected values are 'mention' and 'link'. *)
+  value : string;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:entity}. *)
+val entity_jsont : entity Jsont.t
 
-      end
-      module Like : sig
-(** Record declaring a 'like' of a piece of subject content. *)
+(** Record containing a Bluesky post. *)
 
 type main = {
-  created_at : string;
-  subject : Com.Atproto.Repo.StrongRef.main;
-  via : Com.Atproto.Repo.StrongRef.main option;
+  created_at : string;  (** Client-declared timestamp when this post was originally created. *)
+  embed : Jsont.json option;
+  entities : Jsont.json list option;  (** DEPRECATED: replaced by app.bsky.richtext.facet. *)
+  facets : Richtext.Facet.main list option;  (** Annotations of text (mentions, URLs, hashtags, etc) *)
+  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values for this post. Effectively content warnings. *)
+  langs : string list option;  (** Indicates human language of post primary text content. *)
+  reply : Jsont.json option;
+  tags : string list option;  (** Additional hashtags, in addition to any included in post text and facets. *)
+  text : string;  (** The primary post content. May be an empty string, if there are embeds. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 val output_jsont : output Jsont.t
 
       end
+      module Postgate : sig
+(** Disables embedding of this post. *)
+
+type disable_rule = unit
+
+(** Jsont codec for {!type:disable_rule}. *)
+val disable_rule_jsont : disable_rule Jsont.t
+
+(** Record defining interaction rules for a post. The record key (rkey) of the postgate record must match the record key of the post, and that record must be in the same repository. *)
+
+type main = {
+  created_at : string;
+  detached_embedding_uris : string list option;  (** List of AT-URIs embedding this post that the author has detached from. *)
+  embedding_rules : Jsont.json list option;  (** List of rules defining who can embed this post. If value is an empty array or is undefined, no particular rules apply and anyone can embed. *)
+  post : string;  (** Reference (AT-URI) to the post record. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
       module GetRepostedBy : sig
 (** Get a list of reposts for a given post. *)
 
···
 val output_jsont : output Jsont.t
 
       end
-      module Generator : sig
-(** Record declaring of the existence of a feed generator, and containing metadata about it. The record can exist in any repository. *)
+      module DescribeFeedGenerator : sig
+
+type links = {
+  privacy_policy : string option;
+  terms_of_service : string option;
+}
+
+(** Jsont codec for {!type:links}. *)
+val links_jsont : links Jsont.t
+
+
+type feed = {
+  uri : string;
+}
+
+(** Jsont codec for {!type:feed}. *)
+val feed_jsont : feed Jsont.t
+
+(** Get information about a feed generator, including policies and offered feed URIs. Does not require auth; implemented by Feed Generator services (not App View). *)
 
-type main = {
-  accepts_interactions : bool option;  (** Declaration that a feed accepts feedback interactions from a client through app.bsky.feed.sendInteractions *)
-  avatar : Atp.Blob_ref.t option;
-  content_mode : string option;
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
+
+type output = {
   did : string;
-  display_name : string;
-  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values *)
+  feeds : Jsont.json list;
+  links : Jsont.json option;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-      module Postgate : sig
-(** Disables embedding of this post. *)
+      module Threadgate : sig
+(** Allow replies from actors mentioned in your post. *)
 
-type disable_rule = unit
+type mention_rule = unit
 
-(** Jsont codec for {!type:disable_rule}. *)
-val disable_rule_jsont : disable_rule Jsont.t
+(** Jsont codec for {!type:mention_rule}. *)
+val mention_rule_jsont : mention_rule Jsont.t
+
+(** Allow replies from actors on a list. *)
+
+type list_rule = {
+  list_ : string;
+}
+
+(** Jsont codec for {!type:list_rule}. *)
+val list_rule_jsont : list_rule Jsont.t
 
-(** Record defining interaction rules for a post. The record key (rkey) of the postgate record must match the record key of the post, and that record must be in the same repository. *)
+(** Allow replies from actors you follow. *)
+
+type following_rule = unit
+
+(** Jsont codec for {!type:following_rule}. *)
+val following_rule_jsont : following_rule Jsont.t
+
+(** Allow replies from actors who follow you. *)
+
+type follower_rule = unit
+
+(** Jsont codec for {!type:follower_rule}. *)
+val follower_rule_jsont : follower_rule Jsont.t
+
+(** Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository. *)
 
 type main = {
+  allow : Jsont.json list option;  (** List of rules defining who can reply to this post. If value is an empty array, no one can reply. If value is undefined, anyone can reply. *)
   created_at : string;
-  detached_embedding_uris : string list option;  (** List of AT-URIs embedding this post that the author has detached from. *)
-  embedding_rules : Jsont.json list option;  (** List of rules defining who can embed this post. If value is an empty array or is undefined, no particular rules apply and anyone can embed. *)
+  hidden_replies : string list option;  (** List of hidden reply URIs. *)
   post : string;  (** Reference (AT-URI) to the post record. *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+      module Like : sig
+(** Record declaring a 'like' of a piece of subject content. *)
+
+type main = {
+  created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
+  via : Com.Atproto.Repo.StrongRef.main option;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 val feed_view_post_jsont : feed_view_post Jsont.t
 
       end
-      module Post : sig
-(** Deprecated. Use app.bsky.richtext instead -- A text segment. Start is inclusive, end is exclusive. Indices are for utf16-encoded strings. *)
-
-type text_slice = {
-  end_ : int;
-  start : int;
-}
-
-(** Jsont codec for {!type:text_slice}. *)
-val text_slice_jsont : text_slice Jsont.t
-
-
-type reply_ref = {
-  parent : Com.Atproto.Repo.StrongRef.main;
-  root : Com.Atproto.Repo.StrongRef.main;
-}
-
-(** Jsont codec for {!type:reply_ref}. *)
-val reply_ref_jsont : reply_ref Jsont.t
-
-(** Deprecated: use facets instead. *)
-
-type entity = {
-  index : Jsont.json;
-  type_ : string;  (** Expected values are 'mention' and 'link'. *)
-  value : string;
-}
-
-(** Jsont codec for {!type:entity}. *)
-val entity_jsont : entity Jsont.t
-
-(** Record containing a Bluesky post. *)
+      module Repost : sig
+(** Record representing a 'repost' of an existing Bluesky post. *)
 
 type main = {
-  created_at : string;  (** Client-declared timestamp when this post was originally created. *)
-  embed : Jsont.json option;
-  entities : Jsont.json list option;  (** DEPRECATED: replaced by app.bsky.richtext.facet. *)
-  facets : Richtext.Facet.main list option;  (** Annotations of text (mentions, URLs, hashtags, etc) *)
-  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values for this post. Effectively content warnings. *)
-  langs : string list option;  (** Indicates human language of post primary text content. *)
-  reply : Jsont.json option;
-  tags : string list option;  (** Additional hashtags, in addition to any included in post text and facets. *)
-  text : string;  (** The primary post content. May be an empty string, if there are embeds. *)
+  created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
+  via : Com.Atproto.Repo.StrongRef.main option;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
       end
-      module GetPosts : sig
-(** Gets post views for a specified list of posts (by AT-URI). This is sometimes referred to as 'hydrating' a 'feed skeleton'. *)
+      module Generator : sig
+(** Record declaring of the existence of a feed generator, and containing metadata about it. The record can exist in any repository. *)
 
-(** Query/procedure parameters. *)
-type params = {
-  uris : string list;  (** List of post AT-URIs to return hydrated views for. *)
+type main = {
+  accepts_interactions : bool option;  (** Declaration that a feed accepts feedback interactions from a client through app.bsky.feed.sendInteractions *)
+  avatar : Atp.Blob_ref.t option;
+  content_mode : string option;
+  created_at : string;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
+  did : string;
+  display_name : string;
+  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values *)
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  posts : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
-      module GetQuotes : sig
-(** Get a list of quotes for a given post. *)
+      module GetPostThread : sig
+(** Get posts in a thread. Does not require auth, but additional metadata and filtering will be applied for authed requests. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cid : string option;  (** If supplied, filters to quotes of specific version (by CID) of the post record. *)
-  cursor : string option;
-  limit : int option;
-  uri : string;  (** Reference (AT-URI) of post record *)
+  depth : int option;  (** How many levels of reply depth should be included in response. *)
+  parent_height : int option;  (** How many levels of parent (and grandparent, etc) post to include. *)
+  uri : string;  (** Reference (AT-URI) to post record. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cid : string option;
-  cursor : string option;
-  posts : Jsont.json list;
-  uri : string;
+  thread : Jsont.json;
+  threadgate : Jsont.json option;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetAuthorFeed : sig
-(** Get a view of an actor's 'author feed' (post and reposts by the author). Does not require auth. *)
+      module GetFeed : sig
+(** Get a hydrated feed from an actor's selected feed generator. Implemented by App View. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;
   cursor : string option;
-  filter : string option;  (** Combinations of post/repost types to include in response. *)
-  include_pins : bool option;
+  feed : string;
   limit : int option;
 }
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetTimeline : sig
-(** Get a view of the requesting account's home timeline. This is expected to be some form of reverse-chronological feed. *)
+      module GetQuotes : sig
+(** Get a list of quotes for a given post. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  algorithm : string option;  (** Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism. *)
+  cid : string option;  (** If supplied, filters to quotes of specific version (by CID) of the post record. *)
   cursor : string option;
   limit : int option;
+  uri : string;  (** Reference (AT-URI) of post record *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
+  cid : string option;
   cursor : string option;
-  feed : Jsont.json list;
+  posts : Jsont.json list;
+  uri : string;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestedFeeds : sig
-(** Get a list of suggested feeds (feed generators) for the requesting account. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;
-  feeds : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
       module GetActorLikes : sig
 (** Get a list of posts liked by an actor. Requires auth, actor must be the requesting account. *)
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetActorFeeds : sig
-(** Get a list of feeds (feed generator records) created by the actor (in the actor's repo). *)
+      module GetFeedSkeleton : sig
+(** Get a skeleton of a feed provided by a feed generator. Auth is optional, depending on provider requirements, and provides the DID of the requester. Implemented by Feed Generator Service. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;
   cursor : string option;
+  feed : string;  (** Reference to feed generator record describing the specific feed being requested. *)
   limit : int option;
 }
 
···
 
 type output = {
   cursor : string option;
-  feeds : Jsont.json list;
+  feed : Jsont.json list;
+  req_id : string option;  (** Unique identifier per request that may be passed back alongside interactions. *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val output_jsont : output Jsont.t
 
       end
-      module GetPostThread : sig
-(** Get posts in a thread. Does not require auth, but additional metadata and filtering will be applied for authed requests. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  depth : int option;  (** How many levels of reply depth should be included in response. *)
-  parent_height : int option;  (** How many levels of parent (and grandparent, etc) post to include. *)
-  uri : string;  (** Reference (AT-URI) to post record. *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  thread : Jsont.json;
-  threadgate : Jsont.json option;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetFeedSkeleton : sig
-(** Get a skeleton of a feed provided by a feed generator. Auth is optional, depending on provider requirements, and provides the DID of the requester. Implemented by Feed Generator Service. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  feed : string;  (** Reference to feed generator record describing the specific feed being requested. *)
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;
-  feed : Jsont.json list;
-  req_id : string option;  (** Unique identifier per request that may be passed back alongside interactions. *)
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetFeed : sig
-(** Get a hydrated feed from an actor's selected feed generator. Implemented by App View. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  feed : string;
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;
-  feed : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
       module GetFeedGenerators : sig
 (** Get information about a list of feed generators. *)
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetFeedGenerator : sig
-(** Get information about a feed generator. Implemented by AppView. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  feed : string;  (** AT-URI of the feed generator record. *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  is_online : bool;  (** Indicates whether the feed generator service has been online recently, or else seems to be inactive. *)
-  is_valid : bool;  (** Indicates whether the feed generator service is compatible with the record declaration. *)
-  view : Jsont.json;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-    end
-    module Graph : sig
-      module Defs : sig
-
-type starter_pack_view_basic = {
-  cid : string;
-  creator : Jsont.json;
-  indexed_at : string;
-  joined_all_time_count : int option;
-  joined_week_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  record : Jsont.json;
-  uri : string;
-}
-
-(** Jsont codec for {!type:starter_pack_view_basic}. *)
-val starter_pack_view_basic_jsont : starter_pack_view_basic Jsont.t
-
-(** lists the bi-directional graph relationships between one actor (not indicated in the object), and the target actors (the DID included in the object) *)
-
-type relationship = {
-  blocked_by : string option;  (** if the actor is blocked by this DID, contains the AT-URI of the block record *)
-  blocked_by_list : string option;  (** if the actor is blocked by this DID via a block list, contains the AT-URI of the listblock record *)
-  blocking : string option;  (** if the actor blocks this DID, this is the AT-URI of the block record *)
-  blocking_by_list : string option;  (** if the actor blocks this DID via a block list, this is the AT-URI of the listblock record *)
-  did : string;
-  followed_by : string option;  (** if the actor is followed by this DID, contains the AT-URI of the follow record *)
-  following : string option;  (** if the actor follows this DID, this is the AT-URI of the follow record *)
-}
-
-(** Jsont codec for {!type:relationship}. *)
-val relationship_jsont : relationship Jsont.t
-
-(** A list of actors used for only for reference purposes such as within a starter pack. *)
-
-type referencelist = string
-val referencelist_jsont : referencelist Jsont.t
-
-(** indicates that a handle or DID could not be resolved *)
-
-type not_found_actor = {
-  actor : string;
-  not_found : bool;
-}
-
-(** Jsont codec for {!type:not_found_actor}. *)
-val not_found_actor_jsont : not_found_actor Jsont.t
-
-(** A list of actors to apply an aggregate moderation action (mute/block) on. *)
-
-type modlist = string
-val modlist_jsont : modlist Jsont.t
-
-
-type list_viewer_state = {
-  blocked : string option;
-  muted : bool option;
-}
-
-(** Jsont codec for {!type:list_viewer_state}. *)
-val list_viewer_state_jsont : list_viewer_state Jsont.t
-
-
-type list_purpose = string
-val list_purpose_jsont : list_purpose Jsont.t
-
-
-type list_item_view = {
-  subject : Jsont.json;
-  uri : string;
-}
-
-(** Jsont codec for {!type:list_item_view}. *)
-val list_item_view_jsont : list_item_view Jsont.t
-
-(** A list of actors used for curation purposes such as list feeds or interaction gating. *)
-
-type curatelist = string
-val curatelist_jsont : curatelist Jsont.t
-
-
-type list_view_basic = {
-  avatar : string option;
-  cid : string;
-  indexed_at : string option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  name : string;
-  purpose : Jsont.json;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-(** Jsont codec for {!type:list_view_basic}. *)
-val list_view_basic_jsont : list_view_basic Jsont.t
-
-
-type list_view = {
-  avatar : string option;
-  cid : string;
-  creator : Jsont.json;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_item_count : int option;
-  name : string;
-  purpose : Jsont.json;
-  uri : string;
-  viewer : Jsont.json option;
-}
-
-(** Jsont codec for {!type:list_view}. *)
-val list_view_jsont : list_view Jsont.t
-
-
-type starter_pack_view = {
-  cid : string;
-  creator : Jsont.json;
-  feeds : Jsont.json list option;
-  indexed_at : string;
-  joined_all_time_count : int option;
-  joined_week_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  list_ : Jsont.json option;
-  list_items_sample : Jsont.json list option;
-  record : Jsont.json;
-  uri : string;
-}
-
-(** Jsont codec for {!type:starter_pack_view}. *)
-val starter_pack_view_jsont : starter_pack_view Jsont.t
-
-      end
-      module UnmuteActor : sig
-(** Unmutes the specified account. Requires auth. *)
-
-
-type input = {
-  actor : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module Listitem : sig
-(** Record representing an account's inclusion on a specific list. The AppView will ignore duplicate listitem records. *)
-
-type main = {
-  created_at : string;
-  list_ : string;  (** Reference (AT-URI) to the list record (app.bsky.graph.list). *)
-  subject : string;  (** The account which is included on the list. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module GetSuggestedFollowsByActor : sig
-(** Enumerates follows similar to a given account (actor). Expected use is to recommend additional accounts immediately after following one account. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  actor : string;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  is_fallback : bool option;  (** If true, response has fallen-back to generic results, and is not scoped using relativeToDid *)
-  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
-  suggestions : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module MuteActorList : sig
-(** Creates a mute relationship for the specified list of accounts. Mutes are private in Bluesky. Requires auth. *)
-
-
-type input = {
-  list_ : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module GetFollowers : sig
-(** Enumerates accounts which follow a specified account (actor). *)
+      module GetAuthorFeed : sig
+(** Get a view of an actor's 'author feed' (post and reposts by the author). Does not require auth. *)
 
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
   cursor : string option;
+  filter : string option;  (** Combinations of post/repost types to include in response. *)
+  include_pins : bool option;
   limit : int option;
 }
 
···
 
 type output = {
   cursor : string option;
-  followers : Jsont.json list;
-  subject : Jsont.json;
+  feed : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module MuteActor : sig
-(** Creates a mute relationship for the specified account. Mutes are private in Bluesky. Requires auth. *)
-
-
-type input = {
-  actor : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module UnmuteActorList : sig
-(** Unmutes the specified list of accounts. Requires auth. *)
-
-
-type input = {
-  list_ : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module GetBlocks : sig
-(** Enumerates which accounts the requesting account is currently blocking. Requires auth. *)
+      module GetFeedGenerator : sig
+(** Get information about a feed generator. Implemented by AppView. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  blocks : Jsont.json list;
-  cursor : string option;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module Listblock : sig
-(** Record representing a block relationship against an entire an entire list of accounts (actors). *)
-
-type main = {
-  created_at : string;
-  subject : string;  (** Reference (AT-URI) to the mod list record. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module MuteThread : sig
-(** Mutes a thread preventing notifications from the thread and any of its children. Mutes are private in Bluesky. Requires auth. *)
-
-
-type input = {
-  root : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module Follow : sig
-(** Record declaring a social 'follow' relationship of another account. Duplicate follows will be ignored by the AppView. *)
-
-type main = {
-  created_at : string;
-  subject : string;
-  via : Com.Atproto.Repo.StrongRef.main option;
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module Starterpack : sig
-
-type feed_item = {
-  uri : string;
-}
-
-(** Jsont codec for {!type:feed_item}. *)
-val feed_item_jsont : feed_item Jsont.t
-
-(** Record defining a starter pack of actors and feeds for new users. *)
-
-type main = {
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  feeds : Jsont.json list option;
-  list_ : string;  (** Reference (AT-URI) to the list record. *)
-  name : string;  (** Display name for starter pack; can not be empty. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module GetFollows : sig
-(** Enumerates accounts which a specified account (actor) follows. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  actor : string;
-  cursor : string option;
-  limit : int option;
+  feed : string;  (** AT-URI of the feed generator record. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cursor : string option;
-  follows : Jsont.json list;
-  subject : Jsont.json;
+  is_online : bool;  (** Indicates whether the feed generator service has been online recently, or else seems to be inactive. *)
+  is_valid : bool;  (** Indicates whether the feed generator service is compatible with the record declaration. *)
+  view : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Verification : sig
-(** Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted. *)
-
-type main = {
-  created_at : string;  (** Date of when the verification was created. *)
-  display_name : string;  (** Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying. *)
-  handle : string;  (** Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying. *)
-  subject : string;  (** DID of the subject the verification applies to. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module UnmuteThread : sig
-(** Unmutes the specified thread. Requires auth. *)
-
-
-type input = {
-  root : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module GetMutes : sig
-(** Enumerates accounts that the requesting account (actor) currently has muted. Requires auth. *)
+      module GetSuggestedFeeds : sig
+(** Get a list of suggested feeds (feed generators) for the requesting account. *)
 
 (** Query/procedure parameters. *)
 type params = {
···
 
 type output = {
   cursor : string option;
-  mutes : Jsont.json list;
+  feeds : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetKnownFollowers : sig
-(** Enumerates accounts which follow a specified account (actor) and are followed by the viewer. *)
+      module GetActorFeeds : sig
+(** Get a list of feeds (feed generator records) created by the actor (in the actor's repo). *)
 
 (** Query/procedure parameters. *)
 type params = {
···
 
 type output = {
   cursor : string option;
-  followers : Jsont.json list;
-  subject : Jsont.json;
+  feeds : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Block : sig
-(** Record declaring a 'block' relationship against another account. NOTE: blocks are public in Bluesky; see blog posts for details. *)
-
-type main = {
-  created_at : string;
-  subject : string;  (** DID of the account to be blocked. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-      module GetRelationships : sig
-(** Enumerates public relationships between one account, and a list of other accounts. Does not require auth. *)
+      module GetPosts : sig
+(** Gets post views for a specified list of posts (by AT-URI). This is sometimes referred to as 'hydrating' a 'feed skeleton'. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;  (** Primary account requesting relationships for. *)
-  others : string list option;  (** List of 'other' accounts to be related back to the primary. *)
+  uris : string list;  (** List of post AT-URIs to return hydrated views for. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  actor : string option;
-  relationships : Jsont.json list;
+  posts : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetListsWithMembership : sig
-(** A list and an optional list item indicating membership of a target user to that list. *)
-
-type list_with_membership = {
-  list_ : Jsont.json;
-  list_item : Jsont.json option;
-}
-
-(** Jsont codec for {!type:list_with_membership}. *)
-val list_with_membership_jsont : list_with_membership Jsont.t
-
-(** Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth. *)
+      module GetTimeline : sig
+(** Get a view of the requesting account's home timeline. This is expected to be some form of reverse-chronological feed. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;  (** The account (actor) to check for membership. *)
+  algorithm : string option;  (** Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism. *)
   cursor : string option;
   limit : int option;
-  purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 type output = {
   cursor : string option;
-  lists_with_membership : Jsont.json list;
+  feed : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetListMutes : sig
-(** Enumerates mod lists that the requesting account (actor) currently has muted. Requires auth. *)
+    end
+    module Bookmark : sig
+      module DeleteBookmark : sig
+(** Deletes a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication. *)
 
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
 
-
-type output = {
-  cursor : string option;
-  lists : Jsont.json list;
+type input = {
+  uri : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-      module GetActorStarterPacks : sig
-(** Get a list of starter packs created by the actor. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  actor : string;
-  cursor : string option;
-  limit : int option;
-}
+      module CreateBookmark : sig
+(** Creates a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication. *)
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
 
-
-type output = {
-  cursor : string option;
-  starter_packs : Jsont.json list;
+type input = {
+  cid : string;
+  uri : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-      module SearchStarterPacks : sig
-(** Find starter packs matching search criteria. Does not require auth. *)
+      module Defs : sig
 
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  limit : int option;
-  q : string;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
+type bookmark_view = {
+  created_at : string option;
+  item : Jsont.json;
+  subject : Com.Atproto.Repo.StrongRef.main;  (** A strong ref to the bookmarked record. *)
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:bookmark_view}. *)
+val bookmark_view_jsont : bookmark_view Jsont.t
 
+(** Object used to store bookmark data in stash. *)
 
-type output = {
-  cursor : string option;
-  starter_packs : Jsont.json list;
+type bookmark = {
+  subject : Com.Atproto.Repo.StrongRef.main;  (** A strong ref to the record to be bookmarked. Currently, only `app.bsky.feed.post` records are supported. *)
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:bookmark}. *)
+val bookmark_jsont : bookmark Jsont.t
 
       end
-      module GetStarterPacksWithMembership : sig
-(** A starter pack and an optional list item indicating membership of a target user to that starter pack. *)
-
-type starter_pack_with_membership = {
-  list_item : Jsont.json option;
-  starter_pack : Jsont.json;
-}
-
-(** Jsont codec for {!type:starter_pack_with_membership}. *)
-val starter_pack_with_membership_jsont : starter_pack_with_membership Jsont.t
-
-(** Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth. *)
+      module GetBookmarks : sig
+(** Gets views of records bookmarked by the authenticated user. Requires authentication. *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;  (** The account (actor) to check for membership. *)
   cursor : string option;
   limit : int option;
 }
···
 
 
 type output = {
+  bookmarks : Defs.bookmark_view list;
   cursor : string option;
-  starter_packs_with_membership : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetLists : sig
-(** Enumerates the lists created by a specified account (actor). *)
+    end
+    module Unspecced : sig
+      module GetSuggestedUsersSkeleton : sig
+(** Get a skeleton of suggested users. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsers *)
 
 (** Query/procedure parameters. *)
 type params = {
-  actor : string;  (** The account (actor) to enumerate lists from. *)
-  cursor : string option;
+  category : string option;  (** Category of users to get suggestions for. *)
   limit : int option;
-  purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;
-  lists : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetStarterPack : sig
-(** Gets a view of a starter pack. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  starter_pack : string;  (** Reference (AT-URI) of the starter pack record. *)
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  starter_pack : Jsont.json;
+  dids : string list;
+  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetListBlocks : sig
-(** Get mod lists that the requesting account (actor) is blocking. Requires auth. *)
+      module GetOnboardingSuggestedStarterPacks : sig
+(** Get a list of suggested starterpacks for onboarding *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;
   limit : int option;
 }
 
···
 
 
 type output = {
-  cursor : string option;
-  lists : Jsont.json list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetStarterPacks : sig
-(** Get views for a list of starter packs. *)
-
-(** Query/procedure parameters. *)
-type params = {
-  uris : string list;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
   starter_packs : Jsont.json list;
 }
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetList : sig
-(** Gets a 'view' (with additional context) of a specified list. *)
+      module GetPopularFeedGenerators : sig
+(** An unspecced view of globally popular feed generators. *)
 
 (** Query/procedure parameters. *)
 type params = {
   cursor : string option;
   limit : int option;
-  list_ : string;  (** Reference (AT-URI) of the list record to hydrate. *)
+  query : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 type output = {
   cursor : string option;
-  items : Jsont.json list;
-  list_ : Jsont.json;
+  feeds : Jsont.json list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module List : sig
-(** Record representing a list of accounts (actors). Scope includes both moderation-oriented lists and curration-oriented lists. *)
-
-type main = {
-  avatar : Atp.Blob_ref.t option;
-  created_at : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  name : string;  (** Display name for list; can not be empty. *)
-  purpose : Jsont.json;  (** Defines the purpose of the list (aka, moderation-oriented or curration-oriented) *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-    end
-    module Bookmark : sig
-      module Defs : sig
-
-type bookmark_view = {
-  created_at : string option;
-  item : Jsont.json;
-  subject : Com.Atproto.Repo.StrongRef.main;  (** A strong ref to the bookmarked record. *)
-}
-
-(** Jsont codec for {!type:bookmark_view}. *)
-val bookmark_view_jsont : bookmark_view Jsont.t
-
-(** Object used to store bookmark data in stash. *)
-
-type bookmark = {
-  subject : Com.Atproto.Repo.StrongRef.main;  (** A strong ref to the record to be bookmarked. Currently, only `app.bsky.feed.post` records are supported. *)
-}
-
-(** Jsont codec for {!type:bookmark}. *)
-val bookmark_jsont : bookmark Jsont.t
-
-      end
-      module CreateBookmark : sig
-(** Creates a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication. *)
-
-
-type input = {
-  cid : string;
-  uri : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module DeleteBookmark : sig
-(** Deletes a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication. *)
-
-
-type input = {
-  uri : string;
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-      end
-      module GetBookmarks : sig
-(** Gets views of records bookmarked by the authenticated user. Requires authentication. *)
+      module GetSuggestedStarterPacksSkeleton : sig
+(** Get a skeleton of suggested starterpacks. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedStarterpacks *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;
   limit : int option;
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  bookmarks : Defs.bookmark_view list;
-  cursor : string option;
+  starter_packs : string list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-    end
-    module Unspecced : sig
       module GetSuggestedFeeds : sig
 (** Get a list of suggested feeds *)
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestedUsers : sig
-(** Get a list of suggested users *)
+      module GetSuggestedFeedsSkeleton : sig
+(** Get a skeleton of suggested feeds. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedFeeds *)
 
 (** Query/procedure parameters. *)
 type params = {
-  category : string option;  (** Category of users to get suggestions for. *)
   limit : int option;
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  actors : Jsont.json list;
-  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
+  feeds : string list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestedUsersSkeleton : sig
-(** Get a skeleton of suggested users. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsers *)
+      module GetConfig : sig
 
-(** Query/procedure parameters. *)
-type params = {
-  category : string option;  (** Category of users to get suggestions for. *)
-  limit : int option;
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
+type live_now_config = {
+  did : string;
+  domains : string list;
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:live_now_config}. *)
+val live_now_config_jsont : live_now_config Jsont.t
+
+(** Get miscellaneous runtime configuration. *)
 
 
 type output = {
-  dids : string list;
-  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
+  check_email_confirmed : bool option;
+  live_now : live_now_config list option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val output_jsont : output Jsont.t
 
       end
-      module GetOnboardingSuggestedStarterPacksSkeleton : sig
-(** Get a skeleton of suggested starterpacks for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getOnboardingSuggestedStarterPacks *)
+      module GetSuggestedUsers : sig
+(** Get a list of suggested users *)
 
 (** Query/procedure parameters. *)
 type params = {
+  category : string option;  (** Category of users to get suggestions for. *)
   limit : int option;
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  starter_packs : string list;
+  actors : Jsont.json list;
+  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestedFeedsSkeleton : sig
-(** Get a skeleton of suggested feeds. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedFeeds *)
+      module GetOnboardingSuggestedStarterPacksSkeleton : sig
+(** Get a skeleton of suggested starterpacks for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getOnboardingSuggestedStarterPacks *)
 
 (** Query/procedure parameters. *)
 type params = {
···
 
 
 type output = {
-  feeds : string list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetOnboardingSuggestedStarterPacks : sig
-(** Get a list of suggested starterpacks for onboarding *)
-
-(** Query/procedure parameters. *)
-type params = {
-  limit : int option;
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  starter_packs : Jsont.json list;
+  starter_packs : string list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val age_assurance_event_jsont : age_assurance_event Jsont.t
 
       end
-      module GetConfig : sig
+      module GetTaggedSuggestions : sig
 
-type live_now_config = {
-  did : string;
-  domains : string list;
+type suggestion = {
+  subject : string;
+  subject_type : string;
+  tag : string;
 }
 
-(** Jsont codec for {!type:live_now_config}. *)
-val live_now_config_jsont : live_now_config Jsont.t
+(** Jsont codec for {!type:suggestion}. *)
+val suggestion_jsont : suggestion Jsont.t
+
+(** Get a list of suggestions (feeds and users) tagged with categories *)
 
-(** Get miscellaneous runtime configuration. *)
+(** Query/procedure parameters. *)
+type params = unit
+
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
 type output = {
-  check_email_confirmed : bool option;
-  live_now : live_now_config list option;
+  suggestions : suggestion list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetPopularFeedGenerators : sig
-(** An unspecced view of globally popular feed generators. *)
+      module SearchPostsSkeleton : sig
+(** Backend Posts search, returns only skeleton *)
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;
+  author : string option;  (** Filter to posts by the given account. Handles are resolved to DID before query-time. *)
+  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
+  domain : string option;  (** Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization. *)
+  lang : string option;  (** Filter to posts in the given language. Expected to be based on post language field, though server may override language detection. *)
   limit : int option;
-  query : string option;
+  mentions : string option;  (** Filter to posts which mention the given account. Handles are resolved to DID before query-time. Only matches rich-text facet mentions. *)
+  q : string;  (** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
+  since : string option;  (** Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD). *)
+  sort : string option;  (** Specifies the ranking order of results. *)
+  tag : string list option;  (** Filter to posts with the given tag (hashtag), based on rich-text facet or tag field. Do not include the hash (#) prefix. Multiple tags can be specified, with 'AND' matching. *)
+  until : string option;  (** Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD). *)
+  url : string option;  (** Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching. *)
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used for 'from:me' queries. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 type output = {
   cursor : string option;
-  feeds : Jsont.json list;
+  hits_total : int option;  (** Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits. *)
+  posts : Defs.skeleton_search_post list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetTaggedSuggestions : sig
+      module GetPostThreadV2 : sig
 
-type suggestion = {
-  subject : string;
-  subject_type : string;
-  tag : string;
+type thread_item = {
+  depth : int;  (** The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths. *)
+  uri : string;
+  value : Jsont.json;
 }
 
-(** Jsont codec for {!type:suggestion}. *)
-val suggestion_jsont : suggestion Jsont.t
+(** Jsont codec for {!type:thread_item}. *)
+val thread_item_jsont : thread_item Jsont.t
 
-(** Get a list of suggestions (feeds and users) tagged with categories *)
+(** (NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get posts in a thread. It is based in an anchor post at any depth of the tree, and returns posts above it (recursively resolving the parent, without further branching to their replies) and below it (recursive replies, with branching to their replies). Does not require auth, but additional metadata and filtering will be applied for authed requests. *)
 
 (** Query/procedure parameters. *)
-type params = unit
+type params = {
+  above : bool option;  (** Whether to include parents above the anchor. *)
+  anchor : string;  (** Reference (AT-URI) to post record. This is the anchor post, and the thread will be built around it. It can be any post in the tree, not necessarily a root post. *)
+  below : int option;  (** How many levels of replies to include below the anchor. *)
+  branching_factor : int option;  (** Maximum of replies to include at each level of the thread, except for the direct replies to the anchor, which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated). *)
+  sort : string option;  (** Sorting for the thread replies. *)
+}
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
 
 type output = {
-  suggestions : suggestion list;
+  has_other_replies : bool;  (** Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them. *)
+  thread : thread_item list;  (** A flat list of thread items. The depth of each item is indicated by the depth property inside the item. *)
+  threadgate : Jsont.json option;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestedStarterPacksSkeleton : sig
-(** Get a skeleton of suggested starterpacks. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedStarterpacks *)
+      module GetTrendingTopics : sig
+(** Get a list of trending topics *)
 
 (** Query/procedure parameters. *)
 type params = {
   limit : int option;
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  starter_packs : string list;
+  suggested : Defs.trending_topic list;
+  topics : Defs.trending_topic list;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module InitAgeAssurance : sig
-(** Initiate age assurance for an account. This is a one-time action that will start the process of verifying the user's age. *)
-
-
-type input = {
-  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
-  email : string;  (** The user's email address to receive assurance instructions. *)
-  language : string;  (** The user's preferred language for communication during the assurance process. *)
-}
-
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
-
-
-type output = Defs.age_assurance_state
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetTrendingTopics : sig
-(** Get a list of trending topics *)
+      module GetTrendsSkeleton : sig
+(** Get the skeleton of trends on the network. Intended to be called and then hydrated through app.bsky.unspecced.getTrends *)
 
 (** Query/procedure parameters. *)
 type params = {
   limit : int option;
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  suggested : Defs.trending_topic list;
-  topics : Defs.trending_topic list;
+  trends : Defs.skeleton_trend list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 val output_jsont : output Jsont.t
 
       end
-      module GetSuggestionsSkeleton : sig
-(** Get a skeleton of suggested actors. Intended to be called and then hydrated through app.bsky.actor.getSuggestions *)
+      module InitAgeAssurance : sig
+(** Initiate age assurance for an account. This is a one-time action that will start the process of verifying the user's age. *)
 
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;
-  limit : int option;
-  relative_to_did : string option;  (** DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer. *)
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
-}
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  actors : Defs.skeleton_search_actor list;
-  cursor : string option;
-  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
-  relative_to_did : string option;  (** DID of the account these suggestions are relative to. If this is returned undefined, suggestions are based on the viewer. *)
+type input = {
+  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
+  email : string;  (** The user's email address to receive assurance instructions. *)
+  language : string;  (** The user's preferred language for communication during the assurance process. *)
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module GetAgeAssuranceState : sig
-(** Returns the current state of the age assurance process for an account. This is used to check if the user has completed age assurance or if further action is required. *)
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
 
 type output = Defs.age_assurance_state
···
 val output_jsont : output Jsont.t
 
       end
-      module SearchPostsSkeleton : sig
-(** Backend Posts search, returns only skeleton *)
-
-(** Query/procedure parameters. *)
-type params = {
-  author : string option;  (** Filter to posts by the given account. Handles are resolved to DID before query-time. *)
-  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
-  domain : string option;  (** Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization. *)
-  lang : string option;  (** Filter to posts in the given language. Expected to be based on post language field, though server may override language detection. *)
-  limit : int option;
-  mentions : string option;  (** Filter to posts which mention the given account. Handles are resolved to DID before query-time. Only matches rich-text facet mentions. *)
-  q : string;  (** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
-  since : string option;  (** Filter results for posts after the indicated datetime (inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYYY-MM-DD). *)
-  sort : string option;  (** Specifies the ranking order of results. *)
-  tag : string list option;  (** Filter to posts with the given tag (hashtag), based on rich-text facet or tag field. Do not include the hash (#) prefix. Multiple tags can be specified, with 'AND' matching. *)
-  until : string option;  (** Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD). *)
-  url : string option;  (** Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching. *)
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used for 'from:me' queries. *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;
-  hits_total : int option;  (** Count of search hits. Optional, may be rounded/truncated, and may not be possible to paginate through all hits. *)
-  posts : Defs.skeleton_search_post list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
       module SearchActorsSkeleton : sig
 (** Backend Actors (profile) search, returns only skeleton. *)
 
···
 val output_jsont : output Jsont.t
 
       end
-      module GetTrends : sig
-(** Get the current trends on the network *)
+      module GetAgeAssuranceState : sig
+(** Returns the current state of the age assurance process for an account. This is used to check if the user has completed age assurance or if further action is required. *)
 
-(** Query/procedure parameters. *)
-type params = {
-  limit : int option;
-}
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  trends : Defs.trend_view list;
-}
+type output = Defs.age_assurance_state
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetPostThreadV2 : sig
-
-type thread_item = {
-  depth : int;  (** The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths. *)
-  uri : string;
-  value : Jsont.json;
-}
-
-(** Jsont codec for {!type:thread_item}. *)
-val thread_item_jsont : thread_item Jsont.t
-
-(** (NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get posts in a thread. It is based in an anchor post at any depth of the tree, and returns posts above it (recursively resolving the parent, without further branching to their replies) and below it (recursive replies, with branching to their replies). Does not require auth, but additional metadata and filtering will be applied for authed requests. *)
+      module GetSuggestionsSkeleton : sig
+(** Get a skeleton of suggested actors. Intended to be called and then hydrated through app.bsky.actor.getSuggestions *)
 
 (** Query/procedure parameters. *)
 type params = {
-  above : bool option;  (** Whether to include parents above the anchor. *)
-  anchor : string;  (** Reference (AT-URI) to post record. This is the anchor post, and the thread will be built around it. It can be any post in the tree, not necessarily a root post. *)
-  below : int option;  (** How many levels of replies to include below the anchor. *)
-  branching_factor : int option;  (** Maximum of replies to include at each level of the thread, except for the direct replies to the anchor, which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated). *)
-  sort : string option;  (** Sorting for the thread replies. *)
+  cursor : string option;
+  limit : int option;
+  relative_to_did : string option;  (** DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer. *)
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  has_other_replies : bool;  (** Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them. *)
-  thread : thread_item list;  (** A flat list of thread items. The depth of each item is indicated by the depth property inside the item. *)
-  threadgate : Jsont.json option;
+  actors : Defs.skeleton_search_actor list;
+  cursor : string option;
+  rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
+  relative_to_did : string option;  (** DID of the account these suggestions are relative to. If this is returned undefined, suggestions are based on the viewer. *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module GetTrendsSkeleton : sig
-(** Get the skeleton of trends on the network. Intended to be called and then hydrated through app.bsky.unspecced.getTrends *)
+      module GetTrends : sig
+(** Get the current trends on the network *)
 
 (** Query/procedure parameters. *)
 type params = {
   limit : int option;
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  trends : Defs.skeleton_trend list;
+  trends : Defs.trend_view list;
 }
 
 (** Jsont codec for {!type:output}. *)

lexicons/standard-site/atp_lexicon_standard_site.ml

···
 end
 module Site = struct
   module Standard = struct
+    module Graph = struct
+      module Subscription = struct
+type main = {
+  publication : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ publication -> { publication })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.graph.subscription" ~enc:(fun _ -> "site.standard.graph.subscription")
+  |> Jsont.Object.mem "publication" Jsont.string ~enc:(fun r -> r.publication)
+  |> Jsont.Object.finish
+
+      end
+    end
     module Document = struct
 type main = {
   bsky_post_ref : Com.Atproto.Repo.StrongRef.main option;
···
   |> Jsont.Object.mem "accentForeground" Color.rgb_jsont ~enc:(fun r -> r.accent_foreground)
   |> Jsont.Object.mem "background" Color.rgb_jsont ~enc:(fun r -> r.background)
   |> Jsont.Object.mem "foreground" Color.rgb_jsont ~enc:(fun r -> r.foreground)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Graph = struct
-      module Subscription = struct
-type main = {
-  publication : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ publication -> { publication })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.graph.subscription" ~enc:(fun _ -> "site.standard.graph.subscription")
-  |> Jsont.Object.mem "publication" Jsont.string ~enc:(fun r -> r.publication)
   |> Jsont.Object.finish
 
       end

lexicons/standard-site/atp_lexicon_standard_site.mli

···
 end
 module Site : sig
   module Standard : sig
+    module Graph : sig
+      module Subscription : sig
+(** Record declaring a subscription to a publication. *)
+
+type main = {
+  publication : string;  (** AT-URI reference to the publication record being subscribed to (ex: at://did:plc:abc123/site.standard.publication/xyz789). *)
+}
+
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
+
+      end
+    end
     module Document : sig
 (** A document record representing a published article, blog post, or other content. Documents can belong to a publication or exist independently. *)
 
···
   accent_foreground : Color.rgb;  (** Color used for button text. *)
   background : Color.rgb;  (** Color used for content background. *)
   foreground : Color.rgb;  (** Color used for content text. *)
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-    end
-    module Graph : sig
-      module Subscription : sig
-(** Record declaring a subscription to a publication. *)
-
-type main = {
-  publication : string;  (** AT-URI reference to the publication record being subscribed to (ex: at://did:plc:abc123/site.standard.publication/xyz789). *)
 }
 
 (** Jsont codec for {!type:main}. *)

lexicons/tangled/atp_lexicon_tangled.ml

···
 
 module Sh = struct
   module Tangled = struct
-    module Actor = struct
-      module Profile = struct
-type main = {
-  bluesky : bool;
-  description : string option;
-  links : string list option;
-  location : string option;
-  pinned_repositories : string list option;
-  pronouns : string option;
-  stats : string list option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ bluesky description links location pinned_repositories pronouns stats -> { bluesky; description; links; location; pinned_repositories; pronouns; stats })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.actor.profile" ~enc:(fun _ -> "sh.tangled.actor.profile")
-  |> Jsont.Object.mem "bluesky" Jsont.bool ~enc:(fun r -> r.bluesky)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "links" (Jsont.list Jsont.string) ~enc:(fun r -> r.links)
-  |> Jsont.Object.opt_mem "location" Jsont.string ~enc:(fun r -> r.location)
-  |> Jsont.Object.opt_mem "pinnedRepositories" (Jsont.list Jsont.string) ~enc:(fun r -> r.pinned_repositories)
-  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
-  |> Jsont.Object.opt_mem "stats" (Jsont.list Jsont.string) ~enc:(fun r -> r.stats)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Owner = struct
-type output = {
-  owner : string;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ owner -> { owner })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.owner#output" ~enc:(fun _ -> "sh.tangled.owner#output")
-  |> Jsont.Object.mem "owner" Jsont.string ~enc:(fun r -> r.owner)
-  |> Jsont.Object.finish
-
-    end
     module Spindle = struct
 type main = {
   created_at : string;
···
 
       end
     end
-    module Pipeline = struct
-type trigger_repo = {
-  default_branch : string;
-  did : string;
-  knot : string;
-  repo : string;
-}
-
-let trigger_repo_jsont =
-  Jsont.Object.map ~kind:"Trigger_repo"
-    (fun _typ default_branch did knot repo -> { default_branch; did; knot; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#triggerRepo" ~enc:(fun _ -> "sh.tangled.pipeline#triggerRepo")
-  |> Jsont.Object.mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "knot" Jsont.string ~enc:(fun r -> r.knot)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-type push_trigger_data = {
-  new_sha : string;
-  old_sha : string;
-  ref_ : string;
-}
-
-let push_trigger_data_jsont =
-  Jsont.Object.map ~kind:"Push_trigger_data"
-    (fun _typ new_sha old_sha ref_ -> { new_sha; old_sha; ref_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pushTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#pushTriggerData")
-  |> Jsont.Object.mem "newSha" Jsont.string ~enc:(fun r -> r.new_sha)
-  |> Jsont.Object.mem "oldSha" Jsont.string ~enc:(fun r -> r.old_sha)
-  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.finish
-
-type pull_request_trigger_data = {
-  action : string;
-  source_branch : string;
-  source_sha : string;
-  target_branch : string;
-}
-
-let pull_request_trigger_data_jsont =
-  Jsont.Object.map ~kind:"Pull_request_trigger_data"
-    (fun _typ action source_branch source_sha target_branch -> { action; source_branch; source_sha; target_branch })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pullRequestTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#pullRequestTriggerData")
-  |> Jsont.Object.mem "action" Jsont.string ~enc:(fun r -> r.action)
-  |> Jsont.Object.mem "sourceBranch" Jsont.string ~enc:(fun r -> r.source_branch)
-  |> Jsont.Object.mem "sourceSha" Jsont.string ~enc:(fun r -> r.source_sha)
-  |> Jsont.Object.mem "targetBranch" Jsont.string ~enc:(fun r -> r.target_branch)
-  |> Jsont.Object.finish
-
-type pair = {
-  key : string;
-  value : string;
-}
-
-let pair_jsont =
-  Jsont.Object.map ~kind:"Pair"
-    (fun _typ key value -> { key; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pair" ~enc:(fun _ -> "sh.tangled.pipeline#pair")
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
-  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
-  |> Jsont.Object.finish
-
-type clone_opts = {
-  depth : int;
-  skip : bool;
-  submodules : bool;
-}
-
-let clone_opts_jsont =
-  Jsont.Object.map ~kind:"Clone_opts"
-    (fun _typ depth skip submodules -> { depth; skip; submodules })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#cloneOpts" ~enc:(fun _ -> "sh.tangled.pipeline#cloneOpts")
-  |> Jsont.Object.mem "depth" Jsont.int ~enc:(fun r -> r.depth)
-  |> Jsont.Object.mem "skip" Jsont.bool ~enc:(fun r -> r.skip)
-  |> Jsont.Object.mem "submodules" Jsont.bool ~enc:(fun r -> r.submodules)
-  |> Jsont.Object.finish
-
-type workflow = {
-  clone : clone_opts;
-  engine : string;
-  name : string;
-  raw : string;
-}
-
-let workflow_jsont =
-  Jsont.Object.map ~kind:"Workflow"
-    (fun _typ clone engine name raw -> { clone; engine; name; raw })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#workflow" ~enc:(fun _ -> "sh.tangled.pipeline#workflow")
-  |> Jsont.Object.mem "clone" clone_opts_jsont ~enc:(fun r -> r.clone)
-  |> Jsont.Object.mem "engine" Jsont.string ~enc:(fun r -> r.engine)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "raw" Jsont.string ~enc:(fun r -> r.raw)
-  |> Jsont.Object.finish
-
-type manual_trigger_data = {
-  inputs : pair list option;
-}
-
-let manual_trigger_data_jsont =
-  Jsont.Object.map ~kind:"Manual_trigger_data"
-    (fun _typ inputs -> { inputs })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#manualTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#manualTriggerData")
-  |> Jsont.Object.opt_mem "inputs" (Jsont.list pair_jsont) ~enc:(fun r -> r.inputs)
-  |> Jsont.Object.finish
-
-type trigger_metadata = {
-  kind : string;
-  manual : manual_trigger_data option;
-  pull_request : pull_request_trigger_data option;
-  push : push_trigger_data option;
-  repo : trigger_repo;
-}
-
-let trigger_metadata_jsont =
-  Jsont.Object.map ~kind:"Trigger_metadata"
-    (fun _typ kind manual pull_request push repo -> { kind; manual; pull_request; push; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#triggerMetadata" ~enc:(fun _ -> "sh.tangled.pipeline#triggerMetadata")
-  |> Jsont.Object.mem "kind" Jsont.string ~enc:(fun r -> r.kind)
-  |> Jsont.Object.opt_mem "manual" manual_trigger_data_jsont ~enc:(fun r -> r.manual)
-  |> Jsont.Object.opt_mem "pullRequest" pull_request_trigger_data_jsont ~enc:(fun r -> r.pull_request)
-  |> Jsont.Object.opt_mem "push" push_trigger_data_jsont ~enc:(fun r -> r.push)
-  |> Jsont.Object.mem "repo" trigger_repo_jsont ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-type main = {
-  trigger_metadata : trigger_metadata;
-  workflows : workflow list;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ trigger_metadata workflows -> { trigger_metadata; workflows })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline" ~enc:(fun _ -> "sh.tangled.pipeline")
-  |> Jsont.Object.mem "triggerMetadata" trigger_metadata_jsont ~enc:(fun r -> r.trigger_metadata)
-  |> Jsont.Object.mem "workflows" (Jsont.list workflow_jsont) ~enc:(fun r -> r.workflows)
-  |> Jsont.Object.finish
-
-      module Status = struct
-type main = {
-  created_at : string;
-  error : string option;
-  exit_code : int option;
-  pipeline : string;
-  status : string;
-  workflow : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at error exit_code pipeline status workflow -> { created_at; error; exit_code; pipeline; status; workflow })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline.status" ~enc:(fun _ -> "sh.tangled.pipeline.status")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
-  |> Jsont.Object.opt_mem "exitCode" Jsont.int ~enc:(fun r -> r.exit_code)
-  |> Jsont.Object.mem "pipeline" Jsont.string ~enc:(fun r -> r.pipeline)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.mem "workflow" Jsont.string ~enc:(fun r -> r.workflow)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Knot = struct
-type main = {
-  created_at : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at -> { created_at })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot" ~enc:(fun _ -> "sh.tangled.knot")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.finish
-
-      module Version = struct
-type output = {
-  version : string;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ version -> { version })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.version#output" ~enc:(fun _ -> "sh.tangled.knot.version#output")
-  |> Jsont.Object.mem "version" Jsont.string ~enc:(fun r -> r.version)
-  |> Jsont.Object.finish
-
-      end
-      module ListKeys = struct
-type public_key = {
-  created_at : string;
-  did : string;
-  key : string;
-}
-
-let public_key_jsont =
-  Jsont.Object.map ~kind:"Public_key"
-    (fun _typ created_at did key -> { created_at; did; key })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.listKeys#publicKey" ~enc:(fun _ -> "sh.tangled.knot.listKeys#publicKey")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
-  |> Jsont.Object.finish
-
-type params = {
-  cursor : string option;
-  limit : int option;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun cursor limit -> {
-      cursor;
-      limit;
-    })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.finish
-
-type output = {
-  cursor : string option;
-  keys : public_key list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor keys -> { cursor; keys })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.listKeys#output" ~enc:(fun _ -> "sh.tangled.knot.listKeys#output")
-  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.mem "keys" (Jsont.list public_key_jsont) ~enc:(fun r -> r.keys)
-  |> Jsont.Object.finish
-
-      end
-      module Member = struct
-type main = {
-  created_at : string;
-  domain : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at domain subject -> { created_at; domain; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.member" ~enc:(fun _ -> "sh.tangled.knot.member")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "domain" Jsont.string ~enc:(fun r -> r.domain)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Label = struct
-      module Op = struct
-type operand = {
-  key : string;
-  value : string;
-}
-
-let operand_jsont =
-  Jsont.Object.map ~kind:"Operand"
-    (fun _typ key value -> { key; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.op#operand" ~enc:(fun _ -> "sh.tangled.label.op#operand")
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
-  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
-  |> Jsont.Object.finish
-
-type main = {
-  add : operand list;
-  delete : operand list;
-  performed_at : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ add delete performed_at subject -> { add; delete; performed_at; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.op" ~enc:(fun _ -> "sh.tangled.label.op")
-  |> Jsont.Object.mem "add" (Jsont.list operand_jsont) ~enc:(fun r -> r.add)
-  |> Jsont.Object.mem "delete" (Jsont.list operand_jsont) ~enc:(fun r -> r.delete)
-  |> Jsont.Object.mem "performedAt" Jsont.string ~enc:(fun r -> r.performed_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module Definition = struct
-type value_type = {
-  enum : string list option;
-  format : string;
-  type_ : string;
-}
-
-let value_type_jsont =
-  Jsont.Object.map ~kind:"Value_type"
-    (fun _typ enum format type_ -> { enum; format; type_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.definition#valueType" ~enc:(fun _ -> "sh.tangled.label.definition#valueType")
-  |> Jsont.Object.opt_mem "enum" (Jsont.list Jsont.string) ~enc:(fun r -> r.enum)
-  |> Jsont.Object.mem "format" Jsont.string ~enc:(fun r -> r.format)
-  |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.type_)
-  |> Jsont.Object.finish
-
-type main = {
-  color : string option;
-  created_at : string;
-  multiple : bool option;
-  name : string;
-  scope : string list;
-  value_type : value_type;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ color created_at multiple name scope value_type -> { color; created_at; multiple; name; scope; value_type })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.definition" ~enc:(fun _ -> "sh.tangled.label.definition")
-  |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "multiple" Jsont.bool ~enc:(fun r -> r.multiple)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "scope" (Jsont.list Jsont.string) ~enc:(fun r -> r.scope)
-  |> Jsont.Object.mem "valueType" value_type_jsont ~enc:(fun r -> r.value_type)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module Feed = struct
-      module Reaction = struct
-type main = {
-  created_at : string;
-  reaction : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at reaction subject -> { created_at; reaction; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.feed.reaction" ~enc:(fun _ -> "sh.tangled.feed.reaction")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "reaction" Jsont.string ~enc:(fun r -> r.reaction)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-      module Star = struct
-type main = {
-  created_at : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject -> { created_at; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.feed.star" ~enc:(fun _ -> "sh.tangled.feed.star")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-    end
-    module PublicKey = struct
-type main = {
-  created_at : string;
-  key : string;
-  name : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at key name -> { created_at; key; name })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.publicKey" ~enc:(fun _ -> "sh.tangled.publicKey")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.finish
-
-    end
-    module Graph = struct
-      module Follow = struct
-type main = {
-  created_at : string;
-  subject : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at subject -> { created_at; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.graph.follow" ~enc:(fun _ -> "sh.tangled.graph.follow")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
-      end
-    end
     module Git = struct
       module RefUpdate = struct
 type individual_language_size = {
···
 
       end
     end
+    module Actor = struct
+      module Profile = struct
+type main = {
+  bluesky : bool;
+  description : string option;
+  links : string list option;
+  location : string option;
+  pinned_repositories : string list option;
+  pronouns : string option;
+  stats : string list option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ bluesky description links location pinned_repositories pronouns stats -> { bluesky; description; links; location; pinned_repositories; pronouns; stats })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.actor.profile" ~enc:(fun _ -> "sh.tangled.actor.profile")
+  |> Jsont.Object.mem "bluesky" Jsont.bool ~enc:(fun r -> r.bluesky)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "links" (Jsont.list Jsont.string) ~enc:(fun r -> r.links)
+  |> Jsont.Object.opt_mem "location" Jsont.string ~enc:(fun r -> r.location)
+  |> Jsont.Object.opt_mem "pinnedRepositories" (Jsont.list Jsont.string) ~enc:(fun r -> r.pinned_repositories)
+  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
+  |> Jsont.Object.opt_mem "stats" (Jsont.list Jsont.string) ~enc:(fun r -> r.stats)
+  |> Jsont.Object.finish
+
+      end
+    end
     module String = struct
 type main = {
   contents : string;
···
   |> Jsont.Object.finish
 
     end
+    module Feed = struct
+      module Star = struct
+type main = {
+  created_at : string;
+  subject : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject -> { created_at; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.feed.star" ~enc:(fun _ -> "sh.tangled.feed.star")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
+      end
+      module Reaction = struct
+type main = {
+  created_at : string;
+  reaction : string;
+  subject : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at reaction subject -> { created_at; reaction; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.feed.reaction" ~enc:(fun _ -> "sh.tangled.feed.reaction")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "reaction" Jsont.string ~enc:(fun r -> r.reaction)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
+      end
+    end
     module Repo = struct
 type main = {
   created_at : string;
···
   |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
   |> Jsont.Object.finish
 
-      module Issue = struct
+      module Artifact = struct
 type main = {
-  body : string option;
+  artifact : Atp.Blob_ref.t;
   created_at : string;
-  mentions : string list option;
-  references : string list option;
+  name : string;
   repo : string;
-  title : string;
+  tag : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ body created_at mentions references repo title -> { body; created_at; mentions; references; repo; title })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue" ~enc:(fun _ -> "sh.tangled.repo.issue")
-  |> Jsont.Object.opt_mem "body" Jsont.string ~enc:(fun r -> r.body)
+    (fun _typ artifact created_at name repo tag -> { artifact; created_at; name; repo; tag })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.artifact" ~enc:(fun _ -> "sh.tangled.repo.artifact")
+  |> Jsont.Object.mem "artifact" Atp.Blob_ref.jsont ~enc:(fun r -> r.artifact)
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.mem "tag" Jsont.binary_string ~enc:(fun r -> r.tag)
   |> Jsont.Object.finish
 
-        module Comment = struct
-type main = {
-  body : string;
-  created_at : string;
-  issue : string;
-  mentions : string list option;
-  references : string list option;
-  reply_to : string option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ body created_at issue mentions references reply_to -> { body; created_at; issue; mentions; references; reply_to })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue.comment" ~enc:(fun _ -> "sh.tangled.repo.issue.comment")
-  |> Jsont.Object.mem "body" Jsont.string ~enc:(fun r -> r.body)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "issue" Jsont.string ~enc:(fun r -> r.issue)
-  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
-  |> Jsont.Object.opt_mem "replyTo" Jsont.string ~enc:(fun r -> r.reply_to)
-  |> Jsont.Object.finish
-
-        end
-        module State = struct
-type main = {
-  issue : string;
-  state : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ issue state -> { issue; state })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue.state" ~enc:(fun _ -> "sh.tangled.repo.issue.state")
-  |> Jsont.Object.mem "issue" Jsont.string ~enc:(fun r -> r.issue)
-  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
-  |> Jsont.Object.finish
-
-          module Closed = struct
-type main = string
-let main_jsont = Jsont.string
-
-          end
-          module Open = struct
-type main = string
-let main_jsont = Jsont.string
-
-          end
-        end
       end
-      module Pull = struct
-type target = {
-  branch : string;
-  repo : string;
+      module MergeCheck = struct
+type conflict_info = {
+  filename : string;
+  reason : string;
 }
 
-let target_jsont =
-  Jsont.Object.map ~kind:"Target"
-    (fun _typ branch repo -> { branch; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull#target" ~enc:(fun _ -> "sh.tangled.repo.pull#target")
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+let conflict_info_jsont =
+  Jsont.Object.map ~kind:"Conflict_info"
+    (fun _typ filename reason -> { filename; reason })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#conflictInfo" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#conflictInfo")
+  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
+  |> Jsont.Object.mem "reason" Jsont.string ~enc:(fun r -> r.reason)
   |> Jsont.Object.finish
 
-type source = {
+type input = {
   branch : string;
-  repo : string option;
-  sha : string;
-}
-
-let source_jsont =
-  Jsont.Object.map ~kind:"Source"
-    (fun _typ branch repo sha -> { branch; repo; sha })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull#source" ~enc:(fun _ -> "sh.tangled.repo.pull#source")
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.opt_mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "sha" Jsont.string ~enc:(fun r -> r.sha)
-  |> Jsont.Object.finish
-
-type main = {
-  body : string option;
-  created_at : string;
-  mentions : string list option;
-  patch : string option;
-  patch_blob : Atp.Blob_ref.t;
-  references : string list option;
-  source : source option;
-  target : target;
-  title : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ body created_at mentions patch patch_blob references source target title -> { body; created_at; mentions; patch; patch_blob; references; source; target; title })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull" ~enc:(fun _ -> "sh.tangled.repo.pull")
-  |> Jsont.Object.opt_mem "body" Jsont.string ~enc:(fun r -> r.body)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.opt_mem "patch" Jsont.string ~enc:(fun r -> r.patch)
-  |> Jsont.Object.mem "patchBlob" Atp.Blob_ref.jsont ~enc:(fun r -> r.patch_blob)
-  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
-  |> Jsont.Object.opt_mem "source" source_jsont ~enc:(fun r -> r.source)
-  |> Jsont.Object.mem "target" target_jsont ~enc:(fun r -> r.target)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
-  |> Jsont.Object.finish
-
-        module Comment = struct
-type main = {
-  body : string;
-  created_at : string;
-  mentions : string list option;
-  pull : string;
-  references : string list option;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ body created_at mentions pull references -> { body; created_at; mentions; pull; references })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull.comment" ~enc:(fun _ -> "sh.tangled.repo.pull.comment")
-  |> Jsont.Object.mem "body" Jsont.string ~enc:(fun r -> r.body)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.mem "pull" Jsont.string ~enc:(fun r -> r.pull)
-  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
-  |> Jsont.Object.finish
-
-        end
-        module Status = struct
-type main = {
-  pull : string;
-  status : string;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ pull status -> { pull; status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull.status" ~enc:(fun _ -> "sh.tangled.repo.pull.status")
-  |> Jsont.Object.mem "pull" Jsont.string ~enc:(fun r -> r.pull)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.finish
-
-          module Merged = struct
-type main = string
-let main_jsont = Jsont.string
-
-          end
-          module Closed = struct
-type main = string
-let main_jsont = Jsont.string
-
-          end
-          module Open = struct
-type main = string
-let main_jsont = Jsont.string
-
-          end
-        end
-      end
-      module SetDefaultBranch = struct
-type input = {
-  default_branch : string;
-  repo : string;
+  did : string;
+  name : string;
+  patch : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ default_branch repo -> { default_branch; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.setDefaultBranch#input" ~enc:(fun _ -> "sh.tangled.repo.setDefaultBranch#input")
-  |> Jsont.Object.mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-      end
-      module GetDefaultBranch = struct
-type signature = {
-  email : string;
-  name : string;
-  when_ : string;
-}
-
-let signature_jsont =
-  Jsont.Object.map ~kind:"Signature"
-    (fun _typ email name when_ -> { email; name; when_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.getDefaultBranch#signature" ~enc:(fun _ -> "sh.tangled.repo.getDefaultBranch#signature")
-  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
+    (fun _typ branch did name patch -> { branch; did; name; patch })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#input" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#input")
+  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
-  |> Jsont.Object.finish
-
-type params = {
-  repo : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun repo -> {
-      repo;
-    })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "patch" Jsont.string ~enc:(fun r -> r.patch)
   |> Jsont.Object.finish
 
 type output = {
-  author : signature option;
-  hash : string;
+  conflicts : conflict_info list option;
+  error : string option;
+  is_conflicted : bool;
   message : string option;
-  name : string;
-  short_hash : string option;
-  when_ : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ author hash message name short_hash when_ -> { author; hash; message; name; short_hash; when_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.getDefaultBranch#output" ~enc:(fun _ -> "sh.tangled.repo.getDefaultBranch#output")
-  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
-  |> Jsont.Object.mem "hash" Jsont.string ~enc:(fun r -> r.hash)
+    (fun _typ conflicts error is_conflicted message -> { conflicts; error; is_conflicted; message })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#output" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#output")
+  |> Jsont.Object.opt_mem "conflicts" (Jsont.list conflict_info_jsont) ~enc:(fun r -> r.conflicts)
+  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.mem "is_conflicted" Jsont.bool ~enc:(fun r -> r.is_conflicted)
   |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.opt_mem "shortHash" Jsont.string ~enc:(fun r -> r.short_hash)
-  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
-  |> Jsont.Object.finish
-
-      end
-      module DeleteBranch = struct
-type input = {
-  branch : string;
-  repo : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ branch repo -> { branch; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.deleteBranch#input" ~enc:(fun _ -> "sh.tangled.repo.deleteBranch#input")
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-      end
-      module Delete = struct
-type input = {
-  did : string;
-  name : string;
-  rkey : string;
-}
-
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ did name rkey -> { did; name; rkey })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.delete#input" ~enc:(fun _ -> "sh.tangled.repo.delete#input")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module AddSecret = struct
+      module SetDefaultBranch = struct
 type input = {
-  key : string;
+  default_branch : string;
   repo : string;
-  value : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ key repo value -> { key; repo; value })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.addSecret#input" ~enc:(fun _ -> "sh.tangled.repo.addSecret#input")
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+    (fun _typ default_branch repo -> { default_branch; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.setDefaultBranch#input" ~enc:(fun _ -> "sh.tangled.repo.setDefaultBranch#input")
+  |> Jsont.Object.mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
       end
-      module Branch = struct
-type signature = {
-  email : string;
-  name : string;
-  when_ : string;
-}
-
-let signature_jsont =
-  Jsont.Object.map ~kind:"Signature"
-    (fun _typ email name when_ -> { email; name; when_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.branch#signature" ~enc:(fun _ -> "sh.tangled.repo.branch#signature")
-  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
-  |> Jsont.Object.finish
-
+      module Compare = struct
 type params = {
-  name : string;
   repo : string;
+  rev1 : string;
+  rev2 : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun name repo -> {
-      name;
+    (fun repo rev1 rev2 -> {
       repo;
+      rev1;
+      rev2;
     })
-  |> Jsont.Object.mem "name" Jsont.string
-       ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "rev1" Jsont.string
+       ~enc:(fun r -> r.rev1)
+  |> Jsont.Object.mem "rev2" Jsont.string
+       ~enc:(fun r -> r.rev2)
   |> Jsont.Object.finish
 
-type output = {
-  author : signature option;
-  hash : string;
-  is_default : bool option;
-  message : string option;
+type output = unit
+let output_jsont = Jsont.ignore
+
+      end
+      module Merge = struct
+type input = {
+  author_email : string option;
+  author_name : string option;
+  branch : string;
+  commit_body : string option;
+  commit_message : string option;
+  did : string;
   name : string;
-  short_hash : string option;
-  when_ : string;
+  patch : string;
 }
 
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ author hash is_default message name short_hash when_ -> { author; hash; is_default; message; name; short_hash; when_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.branch#output" ~enc:(fun _ -> "sh.tangled.repo.branch#output")
-  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
-  |> Jsont.Object.mem "hash" Jsont.string ~enc:(fun r -> r.hash)
-  |> Jsont.Object.opt_mem "isDefault" Jsont.bool ~enc:(fun r -> r.is_default)
-  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ author_email author_name branch commit_body commit_message did name patch -> { author_email; author_name; branch; commit_body; commit_message; did; name; patch })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.merge#input" ~enc:(fun _ -> "sh.tangled.repo.merge#input")
+  |> Jsont.Object.opt_mem "authorEmail" Jsont.string ~enc:(fun r -> r.author_email)
+  |> Jsont.Object.opt_mem "authorName" Jsont.string ~enc:(fun r -> r.author_name)
+  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.opt_mem "commitBody" Jsont.string ~enc:(fun r -> r.commit_body)
+  |> Jsont.Object.opt_mem "commitMessage" Jsont.string ~enc:(fun r -> r.commit_message)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.opt_mem "shortHash" Jsont.string ~enc:(fun r -> r.short_hash)
-  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
+  |> Jsont.Object.mem "patch" Jsont.string ~enc:(fun r -> r.patch)
   |> Jsont.Object.finish
 
       end
-      module Log = struct
+      module Tags = struct
 type params = {
   cursor : string option;
   limit : int option;
-  path : string option;
-  ref_ : string;
   repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit path ref_ repo -> {
+    (fun cursor limit repo -> {
       cursor;
       limit;
-      path;
-      ref_;
       repo;
     })
   |> Jsont.Object.opt_mem "cursor" Jsont.string
        ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "limit" Jsont.int
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "path" Jsont.string
-       ~enc:(fun r -> r.path)
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
···
 let output_jsont = Jsont.ignore
 
       end
-      module ListSecrets = struct
-type secret = {
+      module Collaborator = struct
+type main = {
   created_at : string;
-  created_by : string;
-  key : string;
   repo : string;
+  subject : string;
 }
 
-let secret_jsont =
-  Jsont.Object.map ~kind:"Secret"
-    (fun _typ created_at created_by key repo -> { created_at; created_by; key; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.listSecrets#secret" ~enc:(fun _ -> "sh.tangled.repo.listSecrets#secret")
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at repo subject -> { created_at; repo; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.collaborator" ~enc:(fun _ -> "sh.tangled.repo.collaborator")
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "createdBy" Jsont.string ~enc:(fun r -> r.created_by)
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-type params = {
-  repo : string;
-}
-
-let params_jsont =
-  Jsont.Object.map ~kind:"Params"
-    (fun repo -> {
-      repo;
-    })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
-  |> Jsont.Object.finish
-
-type output = {
-  secrets : secret list;
-}
-
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ secrets -> { secrets })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.listSecrets#output" ~enc:(fun _ -> "sh.tangled.repo.listSecrets#output")
-  |> Jsont.Object.mem "secrets" (Jsont.list secret_jsont) ~enc:(fun r -> r.secrets)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> Jsont.Object.finish
 
       end
-      module Tags = struct
+      module Branches = struct
 type params = {
   cursor : string option;
   limit : int option;
···
 let output_jsont = Jsont.ignore
 
       end
-      module Diff = struct
+      module GetDefaultBranch = struct
+type signature = {
+  email : string;
+  name : string;
+  when_ : string;
+}
+
+let signature_jsont =
+  Jsont.Object.map ~kind:"Signature"
+    (fun _typ email name when_ -> { email; name; when_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.getDefaultBranch#signature" ~enc:(fun _ -> "sh.tangled.repo.getDefaultBranch#signature")
+  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
+  |> Jsont.Object.finish
+
 type params = {
-  ref_ : string;
   repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun ref_ repo -> {
-      ref_;
+    (fun repo -> {
       repo;
     })
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
-type output = unit
-let output_jsont = Jsont.ignore
-
-      end
-      module Collaborator = struct
-type main = {
-  created_at : string;
-  repo : string;
-  subject : string;
+type output = {
+  author : signature option;
+  hash : string;
+  message : string option;
+  name : string;
+  short_hash : string option;
+  when_ : string;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ created_at repo subject -> { created_at; repo; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.collaborator" ~enc:(fun _ -> "sh.tangled.repo.collaborator")
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ author hash message name short_hash when_ -> { author; hash; message; name; short_hash; when_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.getDefaultBranch#output" ~enc:(fun _ -> "sh.tangled.repo.getDefaultBranch#output")
+  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "hash" Jsont.string ~enc:(fun r -> r.hash)
+  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.opt_mem "shortHash" Jsont.string ~enc:(fun r -> r.short_hash)
+  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
       end
-      module Artifact = struct
-type main = {
-  artifact : Atp.Blob_ref.t;
-  created_at : string;
+      module ForkStatus = struct
+type input = {
+  branch : string;
+  did : string;
+  hidden_ref : string;
   name : string;
-  repo : string;
-  tag : string;
+  source : string;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ artifact created_at name repo tag -> { artifact; created_at; name; repo; tag })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.artifact" ~enc:(fun _ -> "sh.tangled.repo.artifact")
-  |> Jsont.Object.mem "artifact" Atp.Blob_ref.jsont ~enc:(fun r -> r.artifact)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ branch did hidden_ref name source -> { branch; did; hidden_ref; name; source })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkStatus#input" ~enc:(fun _ -> "sh.tangled.repo.forkStatus#input")
+  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.mem "hiddenRef" Jsont.string ~enc:(fun r -> r.hidden_ref)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "tag" Jsont.binary_string ~enc:(fun r -> r.tag)
+  |> Jsont.Object.mem "source" Jsont.string ~enc:(fun r -> r.source)
+  |> Jsont.Object.finish
+
+type output = {
+  status : int;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ status -> { status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkStatus#output" ~enc:(fun _ -> "sh.tangled.repo.forkStatus#output")
+  |> Jsont.Object.mem "status" Jsont.int ~enc:(fun r -> r.status)
   |> Jsont.Object.finish
 
       end
-      module Archive = struct
+      module Branch = struct
+type signature = {
+  email : string;
+  name : string;
+  when_ : string;
+}
+
+let signature_jsont =
+  Jsont.Object.map ~kind:"Signature"
+    (fun _typ email name when_ -> { email; name; when_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.branch#signature" ~enc:(fun _ -> "sh.tangled.repo.branch#signature")
+  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
+  |> Jsont.Object.finish
+
 type params = {
-  format : string option;
-  prefix : string option;
-  ref_ : string;
+  name : string;
   repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun format prefix ref_ repo -> {
-      format;
-      prefix;
-      ref_;
+    (fun name repo -> {
+      name;
       repo;
     })
-  |> Jsont.Object.opt_mem "format" Jsont.string
-       ~enc:(fun r -> r.format)
-  |> Jsont.Object.opt_mem "prefix" Jsont.string
-       ~enc:(fun r -> r.prefix)
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.mem "name" Jsont.string
+       ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
-type output = unit
-let output_jsont = Jsont.ignore
+type output = {
+  author : signature option;
+  hash : string;
+  is_default : bool option;
+  message : string option;
+  name : string;
+  short_hash : string option;
+  when_ : string;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ author hash is_default message name short_hash when_ -> { author; hash; is_default; message; name; short_hash; when_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.branch#output" ~enc:(fun _ -> "sh.tangled.repo.branch#output")
+  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "hash" Jsont.string ~enc:(fun r -> r.hash)
+  |> Jsont.Object.opt_mem "isDefault" Jsont.bool ~enc:(fun r -> r.is_default)
+  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.opt_mem "shortHash" Jsont.string ~enc:(fun r -> r.short_hash)
+  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
+  |> Jsont.Object.finish
 
       end
-      module RemoveSecret = struct
+      module DeleteBranch = struct
 type input = {
-  key : string;
+  branch : string;
   repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ key repo -> { key; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.removeSecret#input" ~enc:(fun _ -> "sh.tangled.repo.removeSecret#input")
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+    (fun _typ branch repo -> { branch; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.deleteBranch#input" ~enc:(fun _ -> "sh.tangled.repo.deleteBranch#input")
+  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
       end
-      module Merge = struct
-type input = {
-  author_email : string option;
-  author_name : string option;
-  branch : string;
-  commit_body : string option;
-  commit_message : string option;
-  did : string;
-  name : string;
-  patch : string;
+      module Log = struct
+type params = {
+  cursor : string option;
+  limit : int option;
+  path : string option;
+  ref_ : string;
+  repo : string;
 }
 
-let input_jsont =
-  Jsont.Object.map ~kind:"Input"
-    (fun _typ author_email author_name branch commit_body commit_message did name patch -> { author_email; author_name; branch; commit_body; commit_message; did; name; patch })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.merge#input" ~enc:(fun _ -> "sh.tangled.repo.merge#input")
-  |> Jsont.Object.opt_mem "authorEmail" Jsont.string ~enc:(fun r -> r.author_email)
-  |> Jsont.Object.opt_mem "authorName" Jsont.string ~enc:(fun r -> r.author_name)
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.opt_mem "commitBody" Jsont.string ~enc:(fun r -> r.commit_body)
-  |> Jsont.Object.opt_mem "commitMessage" Jsont.string ~enc:(fun r -> r.commit_message)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "patch" Jsont.string ~enc:(fun r -> r.patch)
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun cursor limit path ref_ repo -> {
+      cursor;
+      limit;
+      path;
+      ref_;
+      repo;
+    })
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "path" Jsont.string
+       ~enc:(fun r -> r.path)
+  |> Jsont.Object.mem "ref" Jsont.string
+       ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
+
+type output = unit
+let output_jsont = Jsont.ignore
 
       end
       module Blob = struct
···
   |> Jsont.Object.finish
 
       end
-      module HiddenRef = struct
+      module RemoveSecret = struct
 type input = {
-  fork_ref : string;
-  remote_ref : string;
+  key : string;
   repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ fork_ref remote_ref repo -> { fork_ref; remote_ref; repo })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.hiddenRef#input" ~enc:(fun _ -> "sh.tangled.repo.hiddenRef#input")
-  |> Jsont.Object.mem "forkRef" Jsont.string ~enc:(fun r -> r.fork_ref)
-  |> Jsont.Object.mem "remoteRef" Jsont.string ~enc:(fun r -> r.remote_ref)
+    (fun _typ key repo -> { key; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.removeSecret#input" ~enc:(fun _ -> "sh.tangled.repo.removeSecret#input")
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
-type output = {
-  error : string option;
+      end
+      module Languages = struct
+type language = {
+  color : string option;
+  extensions : string list option;
+  file_count : int option;
+  name : string;
+  percentage : int;
+  size : int;
+}
+
+let language_jsont =
+  Jsont.Object.map ~kind:"Language"
+    (fun _typ color extensions file_count name percentage size -> { color; extensions; file_count; name; percentage; size })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.languages#language" ~enc:(fun _ -> "sh.tangled.repo.languages#language")
+  |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
+  |> Jsont.Object.opt_mem "extensions" (Jsont.list Jsont.string) ~enc:(fun r -> r.extensions)
+  |> Jsont.Object.opt_mem "fileCount" Jsont.int ~enc:(fun r -> r.file_count)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "percentage" Jsont.int ~enc:(fun r -> r.percentage)
+  |> Jsont.Object.mem "size" Jsont.int ~enc:(fun r -> r.size)
+  |> Jsont.Object.finish
+
+type params = {
   ref_ : string option;
-  success : bool;
+  repo : string;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun ref_ repo -> {
+      ref_;
+      repo;
+    })
+  |> Jsont.Object.opt_mem "ref" Jsont.string
+       ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type output = {
+  languages : language list;
+  ref_ : string;
+  total_files : int option;
+  total_size : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ error ref_ success -> { error; ref_; success })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.hiddenRef#output" ~enc:(fun _ -> "sh.tangled.repo.hiddenRef#output")
-  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
-  |> Jsont.Object.opt_mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
+    (fun _typ languages ref_ total_files total_size -> { languages; ref_; total_files; total_size })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.languages#output" ~enc:(fun _ -> "sh.tangled.repo.languages#output")
+  |> Jsont.Object.mem "languages" (Jsont.list language_jsont) ~enc:(fun r -> r.languages)
+  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.opt_mem "totalFiles" Jsont.int ~enc:(fun r -> r.total_files)
+  |> Jsont.Object.opt_mem "totalSize" Jsont.int ~enc:(fun r -> r.total_size)
   |> Jsont.Object.finish
 
       end
-      module Compare = struct
+      module Diff = struct
 type params = {
+  ref_ : string;
   repo : string;
-  rev1 : string;
-  rev2 : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo rev1 rev2 -> {
+    (fun ref_ repo -> {
+      ref_;
       repo;
-      rev1;
-      rev2;
     })
+  |> Jsont.Object.mem "ref" Jsont.string
+       ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "rev1" Jsont.string
-       ~enc:(fun r -> r.rev1)
-  |> Jsont.Object.mem "rev2" Jsont.string
-       ~enc:(fun r -> r.rev2)
   |> Jsont.Object.finish
 
 type output = unit
 let output_jsont = Jsont.ignore
 
       end
-      module ForkStatus = struct
+      module ForkSync = struct
 type input = {
   branch : string;
   did : string;
-  hidden_ref : string;
   name : string;
   source : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ branch did hidden_ref name source -> { branch; did; hidden_ref; name; source })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkStatus#input" ~enc:(fun _ -> "sh.tangled.repo.forkStatus#input")
+    (fun _typ branch did name source -> { branch; did; name; source })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkSync#input" ~enc:(fun _ -> "sh.tangled.repo.forkSync#input")
   |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
   |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "hiddenRef" Jsont.string ~enc:(fun r -> r.hidden_ref)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "source" Jsont.string ~enc:(fun r -> r.source)
   |> Jsont.Object.finish
 
-type output = {
-  status : int;
+      end
+      module AddSecret = struct
+type input = {
+  key : string;
+  repo : string;
+  value : string;
 }
 
-let output_jsont =
-  Jsont.Object.map ~kind:"Output"
-    (fun _typ status -> { status })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkStatus#output" ~enc:(fun _ -> "sh.tangled.repo.forkStatus#output")
-  |> Jsont.Object.mem "status" Jsont.int ~enc:(fun r -> r.status)
+let input_jsont =
+  Jsont.Object.map ~kind:"Input"
+    (fun _typ key repo value -> { key; repo; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.addSecret#input" ~enc:(fun _ -> "sh.tangled.repo.addSecret#input")
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
       end
-      module MergeCheck = struct
-type conflict_info = {
-  filename : string;
-  reason : string;
-}
-
-let conflict_info_jsont =
-  Jsont.Object.map ~kind:"Conflict_info"
-    (fun _typ filename reason -> { filename; reason })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#conflictInfo" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#conflictInfo")
-  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
-  |> Jsont.Object.mem "reason" Jsont.string ~enc:(fun r -> r.reason)
-  |> Jsont.Object.finish
-
+      module Delete = struct
 type input = {
-  branch : string;
   did : string;
   name : string;
-  patch : string;
+  rkey : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ branch did name patch -> { branch; did; name; patch })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#input" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#input")
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+    (fun _typ did name rkey -> { did; name; rkey })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.delete#input" ~enc:(fun _ -> "sh.tangled.repo.delete#input")
   |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "patch" Jsont.string ~enc:(fun r -> r.patch)
+  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
+  |> Jsont.Object.finish
+
+      end
+      module ListSecrets = struct
+type secret = {
+  created_at : string;
+  created_by : string;
+  key : string;
+  repo : string;
+}
+
+let secret_jsont =
+  Jsont.Object.map ~kind:"Secret"
+    (fun _typ created_at created_by key repo -> { created_at; created_by; key; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.listSecrets#secret" ~enc:(fun _ -> "sh.tangled.repo.listSecrets#secret")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "createdBy" Jsont.string ~enc:(fun r -> r.created_by)
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type params = {
+  repo : string;
+}
+
+let params_jsont =
+  Jsont.Object.map ~kind:"Params"
+    (fun repo -> {
+      repo;
+    })
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
 type output = {
-  conflicts : conflict_info list option;
-  error : string option;
-  is_conflicted : bool;
-  message : string option;
+  secrets : secret list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ conflicts error is_conflicted message -> { conflicts; error; is_conflicted; message })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.mergeCheck#output" ~enc:(fun _ -> "sh.tangled.repo.mergeCheck#output")
-  |> Jsont.Object.opt_mem "conflicts" (Jsont.list conflict_info_jsont) ~enc:(fun r -> r.conflicts)
-  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
-  |> Jsont.Object.mem "is_conflicted" Jsont.bool ~enc:(fun r -> r.is_conflicted)
-  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+    (fun _typ secrets -> { secrets })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.listSecrets#output" ~enc:(fun _ -> "sh.tangled.repo.listSecrets#output")
+  |> Jsont.Object.mem "secrets" (Jsont.list secret_jsont) ~enc:(fun r -> r.secrets)
   |> Jsont.Object.finish
 
       end
-      module Branches = struct
+      module Archive = struct
 type params = {
-  cursor : string option;
-  limit : int option;
+  format : string option;
+  prefix : string option;
+  ref_ : string;
   repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun cursor limit repo -> {
-      cursor;
-      limit;
+    (fun format prefix ref_ repo -> {
+      format;
+      prefix;
+      ref_;
       repo;
     })
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "format" Jsont.string
+       ~enc:(fun r -> r.format)
+  |> Jsont.Object.opt_mem "prefix" Jsont.string
+       ~enc:(fun r -> r.prefix)
+  |> Jsont.Object.mem "ref" Jsont.string
+       ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
···
 let output_jsont = Jsont.ignore
 
       end
-      module ForkSync = struct
+      module HiddenRef = struct
 type input = {
-  branch : string;
-  did : string;
-  name : string;
-  source : string;
+  fork_ref : string;
+  remote_ref : string;
+  repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ branch did name source -> { branch; did; name; source })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.forkSync#input" ~enc:(fun _ -> "sh.tangled.repo.forkSync#input")
+    (fun _typ fork_ref remote_ref repo -> { fork_ref; remote_ref; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.hiddenRef#input" ~enc:(fun _ -> "sh.tangled.repo.hiddenRef#input")
+  |> Jsont.Object.mem "forkRef" Jsont.string ~enc:(fun r -> r.fork_ref)
+  |> Jsont.Object.mem "remoteRef" Jsont.string ~enc:(fun r -> r.remote_ref)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type output = {
+  error : string option;
+  ref_ : string option;
+  success : bool;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ error ref_ success -> { error; ref_; success })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.hiddenRef#output" ~enc:(fun _ -> "sh.tangled.repo.hiddenRef#output")
+  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.opt_mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
+  |> Jsont.Object.finish
+
+      end
+      module Pull = struct
+type target = {
+  branch : string;
+  repo : string;
+}
+
+let target_jsont =
+  Jsont.Object.map ~kind:"Target"
+    (fun _typ branch repo -> { branch; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull#target" ~enc:(fun _ -> "sh.tangled.repo.pull#target")
   |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "source" Jsont.string ~enc:(fun r -> r.source)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type source = {
+  branch : string;
+  repo : string option;
+  sha : string;
+}
+
+let source_jsont =
+  Jsont.Object.map ~kind:"Source"
+    (fun _typ branch repo sha -> { branch; repo; sha })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull#source" ~enc:(fun _ -> "sh.tangled.repo.pull#source")
+  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.opt_mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "sha" Jsont.string ~enc:(fun r -> r.sha)
+  |> Jsont.Object.finish
+
+type main = {
+  body : string option;
+  created_at : string;
+  mentions : string list option;
+  patch : string option;
+  patch_blob : Atp.Blob_ref.t;
+  references : string list option;
+  source : source option;
+  target : target;
+  title : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ body created_at mentions patch patch_blob references source target title -> { body; created_at; mentions; patch; patch_blob; references; source; target; title })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull" ~enc:(fun _ -> "sh.tangled.repo.pull")
+  |> Jsont.Object.opt_mem "body" Jsont.string ~enc:(fun r -> r.body)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
+  |> Jsont.Object.opt_mem "patch" Jsont.string ~enc:(fun r -> r.patch)
+  |> Jsont.Object.mem "patchBlob" Atp.Blob_ref.jsont ~enc:(fun r -> r.patch_blob)
+  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
+  |> Jsont.Object.opt_mem "source" source_jsont ~enc:(fun r -> r.source)
+  |> Jsont.Object.mem "target" target_jsont ~enc:(fun r -> r.target)
+  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.finish
+
+        module Comment = struct
+type main = {
+  body : string;
+  created_at : string;
+  mentions : string list option;
+  pull : string;
+  references : string list option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ body created_at mentions pull references -> { body; created_at; mentions; pull; references })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull.comment" ~enc:(fun _ -> "sh.tangled.repo.pull.comment")
+  |> Jsont.Object.mem "body" Jsont.string ~enc:(fun r -> r.body)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
+  |> Jsont.Object.mem "pull" Jsont.string ~enc:(fun r -> r.pull)
+  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
+  |> Jsont.Object.finish
+
+        end
+        module Status = struct
+type main = {
+  pull : string;
+  status : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ pull status -> { pull; status })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.pull.status" ~enc:(fun _ -> "sh.tangled.repo.pull.status")
+  |> Jsont.Object.mem "pull" Jsont.string ~enc:(fun r -> r.pull)
+  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.finish
+
+          module Closed = struct
+type main = string
+let main_jsont = Jsont.string
+
+          end
+          module Open = struct
+type main = string
+let main_jsont = Jsont.string
+
+          end
+          module Merged = struct
+type main = string
+let main_jsont = Jsont.string
+
+          end
+        end
+      end
+      module Issue = struct
+type main = {
+  body : string option;
+  created_at : string;
+  mentions : string list option;
+  references : string list option;
+  repo : string;
+  title : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ body created_at mentions references repo title -> { body; created_at; mentions; references; repo; title })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue" ~enc:(fun _ -> "sh.tangled.repo.issue")
+  |> Jsont.Object.opt_mem "body" Jsont.string ~enc:(fun r -> r.body)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
+  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.finish
+
+        module Comment = struct
+type main = {
+  body : string;
+  created_at : string;
+  issue : string;
+  mentions : string list option;
+  references : string list option;
+  reply_to : string option;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ body created_at issue mentions references reply_to -> { body; created_at; issue; mentions; references; reply_to })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue.comment" ~enc:(fun _ -> "sh.tangled.repo.issue.comment")
+  |> Jsont.Object.mem "body" Jsont.string ~enc:(fun r -> r.body)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "issue" Jsont.string ~enc:(fun r -> r.issue)
+  |> Jsont.Object.opt_mem "mentions" (Jsont.list Jsont.string) ~enc:(fun r -> r.mentions)
+  |> Jsont.Object.opt_mem "references" (Jsont.list Jsont.string) ~enc:(fun r -> r.references)
+  |> Jsont.Object.opt_mem "replyTo" Jsont.string ~enc:(fun r -> r.reply_to)
   |> Jsont.Object.finish
 
+        end
+        module State = struct
+type main = {
+  issue : string;
+  state : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ issue state -> { issue; state })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.issue.state" ~enc:(fun _ -> "sh.tangled.repo.issue.state")
+  |> Jsont.Object.mem "issue" Jsont.string ~enc:(fun r -> r.issue)
+  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
+  |> Jsont.Object.finish
+
+          module Closed = struct
+type main = string
+let main_jsont = Jsont.string
+
+          end
+          module Open = struct
+type main = string
+let main_jsont = Jsont.string
+
+          end
+        end
       end
-      module Languages = struct
-type language = {
+    end
+    module Label = struct
+      module Definition = struct
+type value_type = {
+  enum : string list option;
+  format : string;
+  type_ : string;
+}
+
+let value_type_jsont =
+  Jsont.Object.map ~kind:"Value_type"
+    (fun _typ enum format type_ -> { enum; format; type_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.definition#valueType" ~enc:(fun _ -> "sh.tangled.label.definition#valueType")
+  |> Jsont.Object.opt_mem "enum" (Jsont.list Jsont.string) ~enc:(fun r -> r.enum)
+  |> Jsont.Object.mem "format" Jsont.string ~enc:(fun r -> r.format)
+  |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.type_)
+  |> Jsont.Object.finish
+
+type main = {
   color : string option;
-  extensions : string list option;
-  file_count : int option;
+  created_at : string;
+  multiple : bool option;
   name : string;
-  percentage : int;
-  size : int;
+  scope : string list;
+  value_type : value_type;
 }
 
-let language_jsont =
-  Jsont.Object.map ~kind:"Language"
-    (fun _typ color extensions file_count name percentage size -> { color; extensions; file_count; name; percentage; size })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.languages#language" ~enc:(fun _ -> "sh.tangled.repo.languages#language")
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ color created_at multiple name scope value_type -> { color; created_at; multiple; name; scope; value_type })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.definition" ~enc:(fun _ -> "sh.tangled.label.definition")
   |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
-  |> Jsont.Object.opt_mem "extensions" (Jsont.list Jsont.string) ~enc:(fun r -> r.extensions)
-  |> Jsont.Object.opt_mem "fileCount" Jsont.int ~enc:(fun r -> r.file_count)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "multiple" Jsont.bool ~enc:(fun r -> r.multiple)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "percentage" Jsont.int ~enc:(fun r -> r.percentage)
-  |> Jsont.Object.mem "size" Jsont.int ~enc:(fun r -> r.size)
+  |> Jsont.Object.mem "scope" (Jsont.list Jsont.string) ~enc:(fun r -> r.scope)
+  |> Jsont.Object.mem "valueType" value_type_jsont ~enc:(fun r -> r.value_type)
+  |> Jsont.Object.finish
+
+      end
+      module Op = struct
+type operand = {
+  key : string;
+  value : string;
+}
+
+let operand_jsont =
+  Jsont.Object.map ~kind:"Operand"
+    (fun _typ key value -> { key; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.op#operand" ~enc:(fun _ -> "sh.tangled.label.op#operand")
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
+  |> Jsont.Object.finish
+
+type main = {
+  add : operand list;
+  delete : operand list;
+  performed_at : string;
+  subject : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ add delete performed_at subject -> { add; delete; performed_at; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.label.op" ~enc:(fun _ -> "sh.tangled.label.op")
+  |> Jsont.Object.mem "add" (Jsont.list operand_jsont) ~enc:(fun r -> r.add)
+  |> Jsont.Object.mem "delete" (Jsont.list operand_jsont) ~enc:(fun r -> r.delete)
+  |> Jsont.Object.mem "performedAt" Jsont.string ~enc:(fun r -> r.performed_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
+      end
+    end
+    module Graph = struct
+      module Follow = struct
+type main = {
+  created_at : string;
+  subject : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at subject -> { created_at; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.graph.follow" ~enc:(fun _ -> "sh.tangled.graph.follow")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
+      end
+    end
+    module Knot = struct
+type main = {
+  created_at : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at -> { created_at })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot" ~enc:(fun _ -> "sh.tangled.knot")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.finish
+
+      module Member = struct
+type main = {
+  created_at : string;
+  domain : string;
+  subject : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at domain subject -> { created_at; domain; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.member" ~enc:(fun _ -> "sh.tangled.knot.member")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "domain" Jsont.string ~enc:(fun r -> r.domain)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
+      end
+      module ListKeys = struct
+type public_key = {
+  created_at : string;
+  did : string;
+  key : string;
+}
+
+let public_key_jsont =
+  Jsont.Object.map ~kind:"Public_key"
+    (fun _typ created_at did key -> { created_at; did; key })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.listKeys#publicKey" ~enc:(fun _ -> "sh.tangled.knot.listKeys#publicKey")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
   |> Jsont.Object.finish
 
 type params = {
-  ref_ : string option;
-  repo : string;
+  cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun ref_ repo -> {
-      ref_;
-      repo;
+    (fun cursor limit -> {
+      cursor;
+      limit;
     })
-  |> Jsont.Object.opt_mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
+  |> Jsont.Object.opt_mem "cursor" Jsont.string
+       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "limit" Jsont.int
+       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
-  languages : language list;
-  ref_ : string;
-  total_files : int option;
-  total_size : int option;
+  cursor : string option;
+  keys : public_key list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ languages ref_ total_files total_size -> { languages; ref_; total_files; total_size })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.languages#output" ~enc:(fun _ -> "sh.tangled.repo.languages#output")
-  |> Jsont.Object.mem "languages" (Jsont.list language_jsont) ~enc:(fun r -> r.languages)
+    (fun _typ cursor keys -> { cursor; keys })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.listKeys#output" ~enc:(fun _ -> "sh.tangled.knot.listKeys#output")
+  |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "keys" (Jsont.list public_key_jsont) ~enc:(fun r -> r.keys)
+  |> Jsont.Object.finish
+
+      end
+      module Version = struct
+type output = {
+  version : string;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ version -> { version })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.knot.version#output" ~enc:(fun _ -> "sh.tangled.knot.version#output")
+  |> Jsont.Object.mem "version" Jsont.string ~enc:(fun r -> r.version)
+  |> Jsont.Object.finish
+
+      end
+    end
+    module Owner = struct
+type output = {
+  owner : string;
+}
+
+let output_jsont =
+  Jsont.Object.map ~kind:"Output"
+    (fun _typ owner -> { owner })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.owner#output" ~enc:(fun _ -> "sh.tangled.owner#output")
+  |> Jsont.Object.mem "owner" Jsont.string ~enc:(fun r -> r.owner)
+  |> Jsont.Object.finish
+
+    end
+    module PublicKey = struct
+type main = {
+  created_at : string;
+  key : string;
+  name : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at key name -> { created_at; key; name })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.publicKey" ~enc:(fun _ -> "sh.tangled.publicKey")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.finish
+
+    end
+    module Pipeline = struct
+type trigger_repo = {
+  default_branch : string;
+  did : string;
+  knot : string;
+  repo : string;
+}
+
+let trigger_repo_jsont =
+  Jsont.Object.map ~kind:"Trigger_repo"
+    (fun _typ default_branch did knot repo -> { default_branch; did; knot; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#triggerRepo" ~enc:(fun _ -> "sh.tangled.pipeline#triggerRepo")
+  |> Jsont.Object.mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.mem "knot" Jsont.string ~enc:(fun r -> r.knot)
+  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type push_trigger_data = {
+  new_sha : string;
+  old_sha : string;
+  ref_ : string;
+}
+
+let push_trigger_data_jsont =
+  Jsont.Object.map ~kind:"Push_trigger_data"
+    (fun _typ new_sha old_sha ref_ -> { new_sha; old_sha; ref_ })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pushTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#pushTriggerData")
+  |> Jsont.Object.mem "newSha" Jsont.string ~enc:(fun r -> r.new_sha)
+  |> Jsont.Object.mem "oldSha" Jsont.string ~enc:(fun r -> r.old_sha)
   |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.opt_mem "totalFiles" Jsont.int ~enc:(fun r -> r.total_files)
-  |> Jsont.Object.opt_mem "totalSize" Jsont.int ~enc:(fun r -> r.total_size)
+  |> Jsont.Object.finish
+
+type pull_request_trigger_data = {
+  action : string;
+  source_branch : string;
+  source_sha : string;
+  target_branch : string;
+}
+
+let pull_request_trigger_data_jsont =
+  Jsont.Object.map ~kind:"Pull_request_trigger_data"
+    (fun _typ action source_branch source_sha target_branch -> { action; source_branch; source_sha; target_branch })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pullRequestTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#pullRequestTriggerData")
+  |> Jsont.Object.mem "action" Jsont.string ~enc:(fun r -> r.action)
+  |> Jsont.Object.mem "sourceBranch" Jsont.string ~enc:(fun r -> r.source_branch)
+  |> Jsont.Object.mem "sourceSha" Jsont.string ~enc:(fun r -> r.source_sha)
+  |> Jsont.Object.mem "targetBranch" Jsont.string ~enc:(fun r -> r.target_branch)
+  |> Jsont.Object.finish
+
+type pair = {
+  key : string;
+  value : string;
+}
+
+let pair_jsont =
+  Jsont.Object.map ~kind:"Pair"
+    (fun _typ key value -> { key; value })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#pair" ~enc:(fun _ -> "sh.tangled.pipeline#pair")
+  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
+  |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
+  |> Jsont.Object.finish
+
+type clone_opts = {
+  depth : int;
+  skip : bool;
+  submodules : bool;
+}
+
+let clone_opts_jsont =
+  Jsont.Object.map ~kind:"Clone_opts"
+    (fun _typ depth skip submodules -> { depth; skip; submodules })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#cloneOpts" ~enc:(fun _ -> "sh.tangled.pipeline#cloneOpts")
+  |> Jsont.Object.mem "depth" Jsont.int ~enc:(fun r -> r.depth)
+  |> Jsont.Object.mem "skip" Jsont.bool ~enc:(fun r -> r.skip)
+  |> Jsont.Object.mem "submodules" Jsont.bool ~enc:(fun r -> r.submodules)
+  |> Jsont.Object.finish
+
+type workflow = {
+  clone : clone_opts;
+  engine : string;
+  name : string;
+  raw : string;
+}
+
+let workflow_jsont =
+  Jsont.Object.map ~kind:"Workflow"
+    (fun _typ clone engine name raw -> { clone; engine; name; raw })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#workflow" ~enc:(fun _ -> "sh.tangled.pipeline#workflow")
+  |> Jsont.Object.mem "clone" clone_opts_jsont ~enc:(fun r -> r.clone)
+  |> Jsont.Object.mem "engine" Jsont.string ~enc:(fun r -> r.engine)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.mem "raw" Jsont.string ~enc:(fun r -> r.raw)
+  |> Jsont.Object.finish
+
+type manual_trigger_data = {
+  inputs : pair list option;
+}
+
+let manual_trigger_data_jsont =
+  Jsont.Object.map ~kind:"Manual_trigger_data"
+    (fun _typ inputs -> { inputs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#manualTriggerData" ~enc:(fun _ -> "sh.tangled.pipeline#manualTriggerData")
+  |> Jsont.Object.opt_mem "inputs" (Jsont.list pair_jsont) ~enc:(fun r -> r.inputs)
+  |> Jsont.Object.finish
+
+type trigger_metadata = {
+  kind : string;
+  manual : manual_trigger_data option;
+  pull_request : pull_request_trigger_data option;
+  push : push_trigger_data option;
+  repo : trigger_repo;
+}
+
+let trigger_metadata_jsont =
+  Jsont.Object.map ~kind:"Trigger_metadata"
+    (fun _typ kind manual pull_request push repo -> { kind; manual; pull_request; push; repo })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#triggerMetadata" ~enc:(fun _ -> "sh.tangled.pipeline#triggerMetadata")
+  |> Jsont.Object.mem "kind" Jsont.string ~enc:(fun r -> r.kind)
+  |> Jsont.Object.opt_mem "manual" manual_trigger_data_jsont ~enc:(fun r -> r.manual)
+  |> Jsont.Object.opt_mem "pullRequest" pull_request_trigger_data_jsont ~enc:(fun r -> r.pull_request)
+  |> Jsont.Object.opt_mem "push" push_trigger_data_jsont ~enc:(fun r -> r.push)
+  |> Jsont.Object.mem "repo" trigger_repo_jsont ~enc:(fun r -> r.repo)
+  |> Jsont.Object.finish
+
+type main = {
+  trigger_metadata : trigger_metadata;
+  workflows : workflow list;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ trigger_metadata workflows -> { trigger_metadata; workflows })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline" ~enc:(fun _ -> "sh.tangled.pipeline")
+  |> Jsont.Object.mem "triggerMetadata" trigger_metadata_jsont ~enc:(fun r -> r.trigger_metadata)
+  |> Jsont.Object.mem "workflows" (Jsont.list workflow_jsont) ~enc:(fun r -> r.workflows)
+  |> Jsont.Object.finish
+
+      module Status = struct
+type main = {
+  created_at : string;
+  error : string option;
+  exit_code : int option;
+  pipeline : string;
+  status : string;
+  workflow : string;
+}
+
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
+    (fun _typ created_at error exit_code pipeline status workflow -> { created_at; error; exit_code; pipeline; status; workflow })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline.status" ~enc:(fun _ -> "sh.tangled.pipeline.status")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.opt_mem "exitCode" Jsont.int ~enc:(fun r -> r.exit_code)
+  |> Jsont.Object.mem "pipeline" Jsont.string ~enc:(fun r -> r.pipeline)
+  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.mem "workflow" Jsont.string ~enc:(fun r -> r.workflow)
   |> Jsont.Object.finish
 
       end

lexicons/tangled/atp_lexicon_tangled.mli

···
 
 module Sh : sig
   module Tangled : sig
-    module Actor : sig
-      module Profile : sig
-(** A declaration of a Tangled account profile. *)
-
-type main = {
-  bluesky : bool;  (** Include link to this account on Bluesky. *)
-  description : string option;  (** Free-form profile description text. *)
-  links : string list option;
-  location : string option;  (** Free-form location text. *)
-  pinned_repositories : string list option;  (** Any ATURI, it is up to appviews to validate these fields. *)
-  pronouns : string option;  (** Preferred gender pronouns. *)
-  stats : string list option;
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-      end
-    end
-    module Owner : sig
-(** Get the owner of a service *)
-
-
-type output = {
-  owner : string;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-    end
     module Spindle : sig
 
 type main = {
···
 
       end
     end
-    module Pipeline : sig
-
-type trigger_repo = {
-  default_branch : string;
-  did : string;
-  knot : string;
-  repo : string;
-}
-
-(** Jsont codec for {!type:trigger_repo}. *)
-val trigger_repo_jsont : trigger_repo Jsont.t
-
-
-type push_trigger_data = {
-  new_sha : string;
-  old_sha : string;
-  ref_ : string;
-}
-
-(** Jsont codec for {!type:push_trigger_data}. *)
-val push_trigger_data_jsont : push_trigger_data Jsont.t
-
-
-type pull_request_trigger_data = {
-  action : string;
-  source_branch : string;
-  source_sha : string;
-  target_branch : string;
-}
-
-(** Jsont codec for {!type:pull_request_trigger_data}. *)
-val pull_request_trigger_data_jsont : pull_request_trigger_data Jsont.t
-
+    module Git : sig
+      module RefUpdate : sig
 
-type pair = {
-  key : string;
-  value : string;
+type individual_language_size = {
+  lang : string;
+  size : int;
 }
 
-(** Jsont codec for {!type:pair}. *)
-val pair_jsont : pair Jsont.t
+(** Jsont codec for {!type:individual_language_size}. *)
+val individual_language_size_jsont : individual_language_size Jsont.t
 
 
-type clone_opts = {
-  depth : int;
-  skip : bool;
-  submodules : bool;
+type individual_email_commit_count = {
+  count : int;
+  email : string;
 }
 
-(** Jsont codec for {!type:clone_opts}. *)
-val clone_opts_jsont : clone_opts Jsont.t
+(** Jsont codec for {!type:individual_email_commit_count}. *)
+val individual_email_commit_count_jsont : individual_email_commit_count Jsont.t
 
 
-type workflow = {
-  clone : clone_opts;
-  engine : string;
-  name : string;
-  raw : string;
+type lang_breakdown = {
+  inputs : individual_language_size list option;
 }
 
-(** Jsont codec for {!type:workflow}. *)
-val workflow_jsont : workflow Jsont.t
+(** Jsont codec for {!type:lang_breakdown}. *)
+val lang_breakdown_jsont : lang_breakdown Jsont.t
 
 
-type manual_trigger_data = {
-  inputs : pair list option;
+type commit_count_breakdown = {
+  by_email : individual_email_commit_count list option;
 }
 
-(** Jsont codec for {!type:manual_trigger_data}. *)
-val manual_trigger_data_jsont : manual_trigger_data Jsont.t
+(** Jsont codec for {!type:commit_count_breakdown}. *)
+val commit_count_breakdown_jsont : commit_count_breakdown Jsont.t
 
 
-type trigger_metadata = {
-  kind : string;
-  manual : manual_trigger_data option;
-  pull_request : pull_request_trigger_data option;
-  push : push_trigger_data option;
-  repo : trigger_repo;
+type meta = {
+  commit_count : commit_count_breakdown;
+  is_default_ref : bool;
+  lang_breakdown : lang_breakdown option;
 }
 
-(** Jsont codec for {!type:trigger_metadata}. *)
-val trigger_metadata_jsont : trigger_metadata Jsont.t
+(** Jsont codec for {!type:meta}. *)
+val meta_jsont : meta Jsont.t
 
+(** An update to a git repository, emitted by knots. *)
 
 type main = {
-  trigger_metadata : trigger_metadata;
-  workflows : workflow list;
+  committer_did : string;  (** did of the user that pushed this ref *)
+  meta : meta;
+  new_sha : string;  (** new SHA of this ref *)
+  old_sha : string;  (** old SHA of this ref *)
+  ref_ : string;  (** Ref being updated *)
+  repo_did : string;  (** did of the owner of the repo *)
+  repo_name : string;  (** name of the repo *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-      module Status : sig
+      end
+    end
+    module Actor : sig
+      module Profile : sig
+(** A declaration of a Tangled account profile. *)
 
 type main = {
-  created_at : string;  (** time of creation of this status update *)
-  error : string option;  (** error message if failed *)
-  exit_code : int option;  (** exit code if failed *)
-  pipeline : string;  (** ATURI of the pipeline *)
-  status : string;  (** status of the workflow *)
-  workflow : string;  (** name of the workflow within this pipeline *)
+  bluesky : bool;  (** Include link to this account on Bluesky. *)
+  description : string option;  (** Free-form profile description text. *)
+  links : string list option;
+  location : string option;  (** Free-form location text. *)
+  pinned_repositories : string list option;  (** Any ATURI, it is up to appviews to validate these fields. *)
+  pronouns : string option;  (** Preferred gender pronouns. *)
+  stats : string list option;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
       end
     end
-    module Knot : sig
+    module String : sig
 
 type main = {
+  contents : string;
   created_at : string;
+  description : string;
+  filename : string;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-      module Version : sig
-(** Get the version of a knot *)
-
-
-type output = {
-  version : string;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module ListKeys : sig
-
-type public_key = {
-  created_at : string;  (** Key upload timestamp *)
-  did : string;  (** DID associated with the public key *)
-  key : string;  (** Public key contents *)
-}
-
-(** Jsont codec for {!type:public_key}. *)
-val public_key_jsont : public_key Jsont.t
-
-(** List all public keys stored in the knot server *)
-
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;  (** Pagination cursor *)
-  limit : int option;  (** Maximum number of keys to return *)
-}
-
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
-
-
-type output = {
-  cursor : string option;  (** Pagination cursor for next page *)
-  keys : public_key list;
-}
-
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
-
-      end
-      module Member : sig
+    end
+    module Feed : sig
+      module Star : sig
 
 type main = {
   created_at : string;
-  domain : string;  (** domain that this member now belongs to *)
   subject : string;
 }
 
···
 val main_jsont : main Jsont.t
 
       end
-    end
-    module Label : sig
-      module Op : sig
-
-type operand = {
-  key : string;  (** ATURI to the label definition *)
-  value : string;  (** Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value. *)
-}
-
-(** Jsont codec for {!type:operand}. *)
-val operand_jsont : operand Jsont.t
-
+      module Reaction : sig
 
 type main = {
-  add : operand list;
-  delete : operand list;
-  performed_at : string;
-  subject : string;  (** The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op. *)
+  created_at : string;
+  reaction : string;
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
       end
-      module Definition : sig
-
-type value_type = {
-  enum : string list option;  (** Closed set of values that this label can take. *)
-  format : string;  (** An optional constraint that can be applied on string concrete types. *)
-  type_ : string;  (** The concrete type of this label's value. *)
-}
-
-(** Jsont codec for {!type:value_type}. *)
-val value_type_jsont : value_type Jsont.t
-
+    end
+    module Repo : sig
 
 type main = {
-  color : string option;  (** The hex value for the background color for the label. Appviews may choose to respect this. *)
   created_at : string;
-  multiple : bool option;  (** Whether this label can be repeated for a given entity, eg.: \[reviewer:foo, reviewer:bar\] *)
-  name : string;  (** The display name of this label. *)
-  scope : string list;  (** The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. *)
-  value_type : value_type;  (** The type definition of this label. Appviews may allow sorting for certain types. *)
+  description : string option;
+  knot : string;  (** knot where the repo was created *)
+  labels : string list option;  (** List of labels that this repo subscribes to *)
+  name : string;  (** name of the repo *)
+  source : string option;  (** source of the repo *)
+  spindle : string option;  (** CI runner to send jobs to and receive results from *)
+  topics : string list option;  (** Topics related to the repo *)
+  website : string option;  (** Any URI related to the repo *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-      end
-    end
-    module Feed : sig
-      module Reaction : sig
+      module Artifact : sig
 
 type main = {
-  created_at : string;
-  reaction : string;
-  subject : string;
+  artifact : Atp.Blob_ref.t;  (** the artifact *)
+  created_at : string;  (** time of creation of this artifact *)
+  name : string;  (** name of the artifact *)
+  repo : string;  (** repo that this artifact is being uploaded to *)
+  tag : string;  (** hash of the tag object that this artifact is attached to (only annotated tags are supported) *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
       end
-      module Star : sig
+      module MergeCheck : sig
 
-type main = {
-  created_at : string;
-  subject : string;
+type conflict_info = {
+  filename : string;  (** Name of the conflicted file *)
+  reason : string;  (** Reason for the conflict *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:conflict_info}. *)
+val conflict_info_jsont : conflict_info Jsont.t
 
-      end
-    end
-    module PublicKey : sig
+(** Check if a merge is possible between two branches *)
 
-type main = {
-  created_at : string;  (** key upload timestamp *)
-  key : string;  (** public key contents *)
-  name : string;  (** human-readable name for this key *)
+
+type input = {
+  branch : string;  (** Target branch to merge into *)
+  did : string;  (** DID of the repository owner *)
+  name : string;  (** Name of the repository *)
+  patch : string;  (** Patch or pull request to check for merge conflicts *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-    end
-    module Graph : sig
-      module Follow : sig
 
-type main = {
-  created_at : string;
-  subject : string;
+type output = {
+  conflicts : conflict_info list option;  (** List of files with merge conflicts *)
+  error : string option;  (** Error message if check failed *)
+  is_conflicted : bool;  (** Whether the merge has conflicts *)
+  message : string option;  (** Additional message about the merge check *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
       end
-    end
-    module Git : sig
-      module RefUpdate : sig
+      module Tree : sig
 
-type individual_language_size = {
-  lang : string;
-  size : int;
+type readme = {
+  contents : string;  (** Contents of the readme file *)
+  filename : string;  (** Name of the readme file *)
 }
 
-(** Jsont codec for {!type:individual_language_size}. *)
-val individual_language_size_jsont : individual_language_size Jsont.t
+(** Jsont codec for {!type:readme}. *)
+val readme_jsont : readme Jsont.t
 
 
-type individual_email_commit_count = {
-  count : int;
-  email : string;
+type last_commit = {
+  hash : string;  (** Commit hash *)
+  message : string;  (** Commit message *)
+  when_ : string;  (** Commit timestamp *)
 }
 
-(** Jsont codec for {!type:individual_email_commit_count}. *)
-val individual_email_commit_count_jsont : individual_email_commit_count Jsont.t
+(** Jsont codec for {!type:last_commit}. *)
+val last_commit_jsont : last_commit Jsont.t
 
 
-type lang_breakdown = {
-  inputs : individual_language_size list option;
+type tree_entry = {
+  last_commit : last_commit option;
+  mode : string;  (** File mode *)
+  name : string;  (** Relative file or directory name *)
+  size : int;  (** File size in bytes *)
 }
 
-(** Jsont codec for {!type:lang_breakdown}. *)
-val lang_breakdown_jsont : lang_breakdown Jsont.t
+(** Jsont codec for {!type:tree_entry}. *)
+val tree_entry_jsont : tree_entry Jsont.t
 
 
-type commit_count_breakdown = {
-  by_email : individual_email_commit_count list option;
+(** Query/procedure parameters. *)
+type params = {
+  path : string option;  (** Path within the repository tree *)
+  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
-(** Jsont codec for {!type:commit_count_breakdown}. *)
-val commit_count_breakdown_jsont : commit_count_breakdown Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type meta = {
-  commit_count : commit_count_breakdown;
-  is_default_ref : bool;
-  lang_breakdown : lang_breakdown option;
+type output = {
+  dotdot : string option;  (** Parent directory path *)
+  files : tree_entry list;
+  parent : string option;  (** The parent path in the tree *)
+  readme : readme option;  (** Readme for this file tree *)
+  ref_ : string;  (** The git reference used *)
 }
 
-(** Jsont codec for {!type:meta}. *)
-val meta_jsont : meta Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-(** An update to a git repository, emitted by knots. *)
+      end
+      module SetDefaultBranch : sig
+(** Set the default branch for a repository *)
 
-type main = {
-  committer_did : string;  (** did of the user that pushed this ref *)
-  meta : meta;
-  new_sha : string;  (** new SHA of this ref *)
-  old_sha : string;  (** old SHA of this ref *)
-  ref_ : string;  (** Ref being updated *)
-  repo_did : string;  (** did of the owner of the repo *)
-  repo_name : string;  (** name of the repo *)
+
+type input = {
+  default_branch : string;
+  repo : string;
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
       end
-    end
-    module String : sig
+      module Compare : sig
 
-type main = {
-  contents : string;
-  created_at : string;
-  description : string;
-  filename : string;
+(** Query/procedure parameters. *)
+type params = {
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+  rev1 : string;  (** First revision (commit, branch, or tag) *)
+  rev2 : string;  (** Second revision (commit, branch, or tag) *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-    end
-    module Repo : sig
+(** Compare output in application/json *)
 
-type main = {
-  created_at : string;
-  description : string option;
-  knot : string;  (** knot where the repo was created *)
-  labels : string list option;  (** List of labels that this repo subscribes to *)
-  name : string;  (** name of the repo *)
-  source : string option;  (** source of the repo *)
-  spindle : string option;  (** CI runner to send jobs to and receive results from *)
-  topics : string list option;  (** Topics related to the repo *)
-  website : string option;  (** Any URI related to the repo *)
-}
+type output = unit
+val output_jsont : output Jsont.t
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+      end
+      module Merge : sig
+(** Merge a patch into a repository branch *)
 
-      module Issue : sig
 
-type main = {
-  body : string option;
-  created_at : string;
-  mentions : string list option;
-  references : string list option;
-  repo : string;
-  title : string;
+type input = {
+  author_email : string option;  (** Author email for the merge commit *)
+  author_name : string option;  (** Author name for the merge commit *)
+  branch : string;  (** Target branch to merge into *)
+  commit_body : string option;  (** Additional commit message body *)
+  commit_message : string option;  (** Merge commit message *)
+  did : string;  (** DID of the repository owner *)
+  name : string;  (** Name of the repository *)
+  patch : string;  (** Patch content to merge *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-        module Comment : sig
+      end
+      module Tags : sig
 
-type main = {
-  body : string;
-  created_at : string;
-  issue : string;
-  mentions : string list option;
-  references : string list option;
-  reply_to : string option;
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;  (** Pagination cursor *)
+  limit : int option;  (** Maximum number of tags to return *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-        end
-        module State : sig
+
+type output = unit
+val output_jsont : output Jsont.t
+
+      end
+      module Collaborator : sig
 
 type main = {
-  issue : string;
-  state : string;  (** state of the issue *)
+  created_at : string;
+  repo : string;  (** repo to add this user to *)
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-          module Closed : sig
-(** closed issue *)
-
-type main = string
-val main_jsont : main Jsont.t
-
-          end
-          module Open : sig
-(** open issue *)
-
-type main = string
-val main_jsont : main Jsont.t
-
-          end
-        end
       end
-      module Pull : sig
+      module Branches : sig
 
-type target = {
-  branch : string;
-  repo : string;
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;  (** Pagination cursor *)
+  limit : int option;  (** Maximum number of branches to return *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
-(** Jsont codec for {!type:target}. *)
-val target_jsont : target Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
 
-type source = {
-  branch : string;
-  repo : string option;
-  sha : string;
-}
-
-(** Jsont codec for {!type:source}. *)
-val source_jsont : source Jsont.t
+type output = unit
+val output_jsont : output Jsont.t
 
+      end
+      module GetDefaultBranch : sig
 
-type main = {
-  body : string option;
-  created_at : string;
-  mentions : string list option;
-  patch : string option;  (** (deprecated) use patchBlob instead *)
-  patch_blob : Atp.Blob_ref.t;  (** patch content *)
-  references : string list option;
-  source : source option;
-  target : target;
-  title : string;
+type signature = {
+  email : string;  (** Author email *)
+  name : string;  (** Author name *)
+  when_ : string;  (** Author timestamp *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:signature}. *)
+val signature_jsont : signature Jsont.t
 
-        module Comment : sig
 
-type main = {
-  body : string;
-  created_at : string;
-  mentions : string list option;
-  pull : string;
-  references : string list option;
+(** Query/procedure parameters. *)
+type params = {
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
 
-        end
-        module Status : sig
 
-type main = {
-  pull : string;
-  status : string;  (** status of the pull request *)
+type output = {
+  author : signature option;
+  hash : string;  (** Latest commit hash on default branch *)
+  message : string option;  (** Latest commit message *)
+  name : string;  (** Default branch name *)
+  short_hash : string option;  (** Short commit hash *)
+  when_ : string;  (** Timestamp of latest commit *)
 }
 
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-          module Merged : sig
-(** merged pull request *)
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
 
-type main = string
-val main_jsont : main Jsont.t
+      end
+      module Create : sig
+(** Create a new repository *)
 
-          end
-          module Closed : sig
-(** closed pull request *)
 
-type main = string
-val main_jsont : main Jsont.t
-
-          end
-          module Open : sig
-(** open pull request *)
+type input = {
+  default_branch : string option;  (** Default branch to push to *)
+  rkey : string;  (** Rkey of the repository record *)
+  source : string option;  (** A source URL to clone from, populate this when forking or importing a repository. *)
+}
 
-type main = string
-val main_jsont : main Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
-          end
-        end
       end
-      module SetDefaultBranch : sig
-(** Set the default branch for a repository *)
+      module ForkStatus : sig
+(** Check fork status relative to upstream source *)
 
 
 type input = {
-  default_branch : string;
-  repo : string;
+  branch : string;  (** Branch to check status for *)
+  did : string;  (** DID of the fork owner *)
+  hidden_ref : string;  (** Hidden ref to use for comparison *)
+  name : string;  (** Name of the forked repository *)
+  source : string;  (** Source repository URL *)
 }
 
 (** Jsont codec for {!type:input}. *)
 val input_jsont : input Jsont.t
 
+
+type output = {
+  status : int;  (** Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch *)
+}
+
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
       end
-      module GetDefaultBranch : sig
+      module Branch : sig
 
 type signature = {
   email : string;  (** Author email *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  name : string;  (** Branch name to get information for *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
···
 
 type output = {
   author : signature option;
-  hash : string;  (** Latest commit hash on default branch *)
+  hash : string;  (** Latest commit hash on this branch *)
+  is_default : bool option;  (** Whether this is the default branch *)
   message : string option;  (** Latest commit message *)
-  name : string;  (** Default branch name *)
+  name : string;  (** Branch name *)
   short_hash : string option;  (** Short commit hash *)
   when_ : string;  (** Timestamp of latest commit *)
 }
···
 val input_jsont : input Jsont.t
 
       end
-      module Delete : sig
-(** Delete a repository *)
-
+      module Log : sig
 
-type input = {
-  did : string;  (** DID of the repository owner *)
-  name : string;  (** Name of the repository to delete *)
-  rkey : string;  (** Rkey of the repository record *)
+(** Query/procedure parameters. *)
+type params = {
+  cursor : string option;  (** Pagination cursor (commit SHA) *)
+  limit : int option;  (** Maximum number of commits to return *)
+  path : string option;  (** Path to filter commits by *)
+  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:params}. *)
+val params_jsont : params Jsont.t
+
+
+type output = unit
+val output_jsont : output Jsont.t
 
       end
-      module Tree : sig
+      module Blob : sig
 
-type readme = {
-  contents : string;  (** Contents of the readme file *)
-  filename : string;  (** Name of the readme file *)
+type submodule = {
+  branch : string option;  (** Branch to track in the submodule *)
+  name : string;  (** Submodule name *)
+  url : string;  (** Submodule repository URL *)
 }
 
-(** Jsont codec for {!type:readme}. *)
-val readme_jsont : readme Jsont.t
+(** Jsont codec for {!type:submodule}. *)
+val submodule_jsont : submodule Jsont.t
+
+
+type signature = {
+  email : string;  (** Author email *)
+  name : string;  (** Author name *)
+  when_ : string;  (** Author timestamp *)
+}
+
+(** Jsont codec for {!type:signature}. *)
+val signature_jsont : signature Jsont.t
 
 
 type last_commit = {
+  author : signature option;
   hash : string;  (** Commit hash *)
   message : string;  (** Commit message *)
+  short_hash : string option;  (** Short commit hash *)
   when_ : string;  (** Commit timestamp *)
 }
 
···
 val last_commit_jsont : last_commit Jsont.t
 
 
-type tree_entry = {
-  last_commit : last_commit option;
-  mode : string;  (** File mode *)
-  name : string;  (** Relative file or directory name *)
-  size : int;  (** File size in bytes *)
-}
-
-(** Jsont codec for {!type:tree_entry}. *)
-val tree_entry_jsont : tree_entry Jsont.t
-
-
 (** Query/procedure parameters. *)
 type params = {
-  path : string option;  (** Path within the repository tree *)
+  path : string;  (** Path to the file within the repository *)
+  raw : bool option;  (** Return raw file content instead of JSON response *)
   ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
···
 
 
 type output = {
-  dotdot : string option;  (** Parent directory path *)
-  files : tree_entry list;
-  parent : string option;  (** The parent path in the tree *)
-  readme : readme option;  (** Readme for this file tree *)
+  content : string option;  (** File content (base64 encoded for binary files) *)
+  encoding : string option;  (** Content encoding *)
+  is_binary : bool option;  (** Whether the file is binary *)
+  last_commit : last_commit option;
+  mime_type : string option;  (** MIME type of the file *)
+  path : string;  (** The file path *)
   ref_ : string;  (** The git reference used *)
+  size : int option;  (** File size in bytes *)
+  submodule : submodule option;  (** Submodule information if path is a submodule *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module AddSecret : sig
-(** Add a CI secret *)
+      module RemoveSecret : sig
+(** Remove a CI secret *)
 
 
 type input = {
   key : string;
   repo : string;
-  value : string;
 }
 
 (** Jsont codec for {!type:input}. *)
 val input_jsont : input Jsont.t
 
       end
-      module Branch : sig
+      module Languages : sig
 
-type signature = {
-  email : string;  (** Author email *)
-  name : string;  (** Author name *)
-  when_ : string;  (** Author timestamp *)
+type language = {
+  color : string option;  (** Hex color code for this language *)
+  extensions : string list option;  (** File extensions associated with this language *)
+  file_count : int option;  (** Number of files in this language *)
+  name : string;  (** Programming language name *)
+  percentage : int;  (** Percentage of total codebase (0-100) *)
+  size : int;  (** Total size of files in this language (bytes) *)
 }
 
-(** Jsont codec for {!type:signature}. *)
-val signature_jsont : signature Jsont.t
+(** Jsont codec for {!type:language}. *)
+val language_jsont : language Jsont.t
 
 
 (** Query/procedure parameters. *)
 type params = {
-  name : string;  (** Branch name to get information for *)
+  ref_ : string option;  (** Git reference (branch, tag, or commit SHA) *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
···
 
 
 type output = {
-  author : signature option;
-  hash : string;  (** Latest commit hash on this branch *)
-  is_default : bool option;  (** Whether this is the default branch *)
-  message : string option;  (** Latest commit message *)
-  name : string;  (** Branch name *)
-  short_hash : string option;  (** Short commit hash *)
-  when_ : string;  (** Timestamp of latest commit *)
+  languages : language list;
+  ref_ : string;  (** The git reference used *)
+  total_files : int option;  (** Total number of files analyzed *)
+  total_size : int option;  (** Total size of all analyzed files in bytes *)
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Log : sig
+      module Diff : sig
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;  (** Pagination cursor (commit SHA) *)
-  limit : int option;  (** Maximum number of commits to return *)
-  path : string option;  (** Path to filter commits by *)
   ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
···
 val output_jsont : output Jsont.t
 
       end
+      module ForkSync : sig
+(** Sync a forked repository with its upstream source *)
+
+
+type input = {
+  branch : string;  (** Branch to sync *)
+  did : string;  (** DID of the fork owner *)
+  name : string;  (** Name of the forked repository *)
+  source : string;  (** AT-URI of the source repository *)
+}
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+      end
+      module AddSecret : sig
+(** Add a CI secret *)
+
+
+type input = {
+  key : string;
+  repo : string;
+  value : string;
+}
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+      end
+      module Delete : sig
+(** Delete a repository *)
+
+
+type input = {
+  did : string;  (** DID of the repository owner *)
+  name : string;  (** Name of the repository to delete *)
+  rkey : string;  (** Rkey of the repository record *)
+}
+
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
+
+      end
       module ListSecrets : sig
 
 type secret = {
···
 val output_jsont : output Jsont.t
 
       end
-      module Tags : sig
+      module Archive : sig
 
 (** Query/procedure parameters. *)
 type params = {
-  cursor : string option;  (** Pagination cursor *)
-  limit : int option;  (** Maximum number of tags to return *)
+  format : string option;  (** Archive format *)
+  prefix : string option;  (** Prefix for files in the archive *)
+  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
+(** Binary archive data *)
 
 type output = unit
 val output_jsont : output Jsont.t
 
       end
-      module Diff : sig
+      module HiddenRef : sig
+(** Create a hidden ref in a repository *)
+
 
-(** Query/procedure parameters. *)
-type params = {
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+type input = {
+  fork_ref : string;  (** Fork reference name *)
+  remote_ref : string;  (** Remote reference name *)
+  repo : string;  (** AT-URI of the repository *)
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:input}. *)
+val input_jsont : input Jsont.t
 
 
-type output = unit
+type output = {
+  error : string option;  (** Error message if creation failed *)
+  ref_ : string option;  (** The created hidden ref name *)
+  success : bool;  (** Whether the hidden ref was created successfully *)
+}
+
+(** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module Collaborator : sig
+      module Pull : sig
+
+type target = {
+  branch : string;
+  repo : string;
+}
+
+(** Jsont codec for {!type:target}. *)
+val target_jsont : target Jsont.t
+
+
+type source = {
+  branch : string;
+  repo : string option;
+  sha : string;
+}
+
+(** Jsont codec for {!type:source}. *)
+val source_jsont : source Jsont.t
+
 
 type main = {
+  body : string option;
   created_at : string;
-  repo : string;  (** repo to add this user to *)
-  subject : string;
+  mentions : string list option;
+  patch : string option;  (** (deprecated) use patchBlob instead *)
+  patch_blob : Atp.Blob_ref.t;  (** patch content *)
+  references : string list option;
+  source : source option;
+  target : target;
+  title : string;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-      end
-      module Create : sig
-(** Create a new repository *)
+        module Comment : sig
 
-
-type input = {
-  default_branch : string option;  (** Default branch to push to *)
-  rkey : string;  (** Rkey of the repository record *)
-  source : string option;  (** A source URL to clone from, populate this when forking or importing a repository. *)
+type main = {
+  body : string;
+  created_at : string;
+  mentions : string list option;
+  pull : string;
+  references : string list option;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-      end
-      module Artifact : sig
+        end
+        module Status : sig
 
 type main = {
-  artifact : Atp.Blob_ref.t;  (** the artifact *)
-  created_at : string;  (** time of creation of this artifact *)
-  name : string;  (** name of the artifact *)
-  repo : string;  (** repo that this artifact is being uploaded to *)
-  tag : string;  (** hash of the tag object that this artifact is attached to (only annotated tags are supported) *)
+  pull : string;
+  status : string;  (** status of the pull request *)
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
+          module Closed : sig
+(** closed pull request *)
+
+type main = string
+val main_jsont : main Jsont.t
+
+          end
+          module Open : sig
+(** open pull request *)
+
+type main = string
+val main_jsont : main Jsont.t
+
+          end
+          module Merged : sig
+(** merged pull request *)
+
+type main = string
+val main_jsont : main Jsont.t
+
+          end
+        end
       end
-      module Archive : sig
+      module Issue : sig
 
-(** Query/procedure parameters. *)
-type params = {
-  format : string option;  (** Archive format *)
-  prefix : string option;  (** Prefix for files in the archive *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+type main = {
+  body : string option;
+  created_at : string;
+  mentions : string list option;
+  references : string list option;
+  repo : string;
+  title : string;
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-(** Binary archive data *)
+        module Comment : sig
 
-type output = unit
-val output_jsont : output Jsont.t
+type main = {
+  body : string;
+  created_at : string;
+  issue : string;
+  mentions : string list option;
+  references : string list option;
+  reply_to : string option;
+}
 
-      end
-      module RemoveSecret : sig
-(** Remove a CI secret *)
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+        end
+        module State : sig
 
-type input = {
-  key : string;
-  repo : string;
+type main = {
+  issue : string;
+  state : string;  (** state of the issue *)
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-      end
-      module Merge : sig
-(** Merge a patch into a repository branch *)
+          module Closed : sig
+(** closed issue *)
 
+type main = string
+val main_jsont : main Jsont.t
 
-type input = {
-  author_email : string option;  (** Author email for the merge commit *)
-  author_name : string option;  (** Author name for the merge commit *)
-  branch : string;  (** Target branch to merge into *)
-  commit_body : string option;  (** Additional commit message body *)
-  commit_message : string option;  (** Merge commit message *)
-  did : string;  (** DID of the repository owner *)
-  name : string;  (** Name of the repository *)
-  patch : string;  (** Patch content to merge *)
-}
+          end
+          module Open : sig
+(** open issue *)
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+type main = string
+val main_jsont : main Jsont.t
 
+          end
+        end
       end
-      module Blob : sig
+    end
+    module Label : sig
+      module Definition : sig
 
-type submodule = {
-  branch : string option;  (** Branch to track in the submodule *)
-  name : string;  (** Submodule name *)
-  url : string;  (** Submodule repository URL *)
+type value_type = {
+  enum : string list option;  (** Closed set of values that this label can take. *)
+  format : string;  (** An optional constraint that can be applied on string concrete types. *)
+  type_ : string;  (** The concrete type of this label's value. *)
 }
 
-(** Jsont codec for {!type:submodule}. *)
-val submodule_jsont : submodule Jsont.t
+(** Jsont codec for {!type:value_type}. *)
+val value_type_jsont : value_type Jsont.t
 
 
-type signature = {
-  email : string;  (** Author email *)
-  name : string;  (** Author name *)
-  when_ : string;  (** Author timestamp *)
+type main = {
+  color : string option;  (** The hex value for the background color for the label. Appviews may choose to respect this. *)
+  created_at : string;
+  multiple : bool option;  (** Whether this label can be repeated for a given entity, eg.: \[reviewer:foo, reviewer:bar\] *)
+  name : string;  (** The display name of this label. *)
+  scope : string list;  (** The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. *)
+  value_type : value_type;  (** The type definition of this label. Appviews may allow sorting for certain types. *)
 }
 
-(** Jsont codec for {!type:signature}. *)
-val signature_jsont : signature Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+      end
+      module Op : sig
 
-type last_commit = {
-  author : signature option;
-  hash : string;  (** Commit hash *)
-  message : string;  (** Commit message *)
-  short_hash : string option;  (** Short commit hash *)
-  when_ : string;  (** Commit timestamp *)
+type operand = {
+  key : string;  (** ATURI to the label definition *)
+  value : string;  (** Stringified value of the label. This is first unstringed by appviews and then interpreted as a concrete value. *)
 }
 
-(** Jsont codec for {!type:last_commit}. *)
-val last_commit_jsont : last_commit Jsont.t
+(** Jsont codec for {!type:operand}. *)
+val operand_jsont : operand Jsont.t
 
 
-(** Query/procedure parameters. *)
-type params = {
-  path : string;  (** Path to the file within the repository *)
-  raw : bool option;  (** Return raw file content instead of JSON response *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+type main = {
+  add : operand list;
+  delete : operand list;
+  performed_at : string;
+  subject : string;  (** The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op. *)
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+      end
+    end
+    module Graph : sig
+      module Follow : sig
 
-type output = {
-  content : string option;  (** File content (base64 encoded for binary files) *)
-  encoding : string option;  (** Content encoding *)
-  is_binary : bool option;  (** Whether the file is binary *)
-  last_commit : last_commit option;
-  mime_type : string option;  (** MIME type of the file *)
-  path : string;  (** The file path *)
-  ref_ : string;  (** The git reference used *)
-  size : int option;  (** File size in bytes *)
-  submodule : submodule option;  (** Submodule information if path is a submodule *)
+type main = {
+  created_at : string;
+  subject : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
-      module HiddenRef : sig
-(** Create a hidden ref in a repository *)
-
+    end
+    module Knot : sig
 
-type input = {
-  fork_ref : string;  (** Fork reference name *)
-  remote_ref : string;  (** Remote reference name *)
-  repo : string;  (** AT-URI of the repository *)
+type main = {
+  created_at : string;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+      module Member : sig
 
-type output = {
-  error : string option;  (** Error message if creation failed *)
-  ref_ : string option;  (** The created hidden ref name *)
-  success : bool;  (** Whether the hidden ref was created successfully *)
+type main = {
+  created_at : string;
+  domain : string;  (** domain that this member now belongs to *)
+  subject : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
-      module Compare : sig
+      module ListKeys : sig
+
+type public_key = {
+  created_at : string;  (** Key upload timestamp *)
+  did : string;  (** DID associated with the public key *)
+  key : string;  (** Public key contents *)
+}
+
+(** Jsont codec for {!type:public_key}. *)
+val public_key_jsont : public_key Jsont.t
+
+(** List all public keys stored in the knot server *)
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  rev1 : string;  (** First revision (commit, branch, or tag) *)
-  rev2 : string;  (** Second revision (commit, branch, or tag) *)
+  cursor : string option;  (** Pagination cursor *)
+  limit : int option;  (** Maximum number of keys to return *)
 }
 
 (** Jsont codec for {!type:params}. *)
 val params_jsont : params Jsont.t
 
-(** Compare output in application/json *)
 
-type output = unit
+type output = {
+  cursor : string option;  (** Pagination cursor for next page *)
+  keys : public_key list;
+}
+
+(** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
       end
-      module ForkStatus : sig
-(** Check fork status relative to upstream source *)
+      module Version : sig
+(** Get the version of a knot *)
 
 
-type input = {
-  branch : string;  (** Branch to check status for *)
-  did : string;  (** DID of the fork owner *)
-  hidden_ref : string;  (** Hidden ref to use for comparison *)
-  name : string;  (** Name of the forked repository *)
-  source : string;  (** Source repository URL *)
+type output = {
+  version : string;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:output}. *)
+val output_jsont : output Jsont.t
+
+      end
+    end
+    module Owner : sig
+(** Get the owner of a service *)
 
 
 type output = {
-  status : int;  (** Fork status: 0=UpToDate, 1=FastForwardable, 2=Conflict, 3=MissingBranch *)
+  owner : string;
 }
 
 (** Jsont codec for {!type:output}. *)
 val output_jsont : output Jsont.t
 
-      end
-      module MergeCheck : sig
+    end
+    module PublicKey : sig
 
-type conflict_info = {
-  filename : string;  (** Name of the conflicted file *)
-  reason : string;  (** Reason for the conflict *)
+type main = {
+  created_at : string;  (** key upload timestamp *)
+  key : string;  (** public key contents *)
+  name : string;  (** human-readable name for this key *)
 }
 
-(** Jsont codec for {!type:conflict_info}. *)
-val conflict_info_jsont : conflict_info Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
-(** Check if a merge is possible between two branches *)
+    end
+    module Pipeline : sig
 
+type trigger_repo = {
+  default_branch : string;
+  did : string;
+  knot : string;
+  repo : string;
+}
 
-type input = {
-  branch : string;  (** Target branch to merge into *)
-  did : string;  (** DID of the repository owner *)
-  name : string;  (** Name of the repository *)
-  patch : string;  (** Patch or pull request to check for merge conflicts *)
+(** Jsont codec for {!type:trigger_repo}. *)
+val trigger_repo_jsont : trigger_repo Jsont.t
+
+
+type push_trigger_data = {
+  new_sha : string;
+  old_sha : string;
+  ref_ : string;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:push_trigger_data}. *)
+val push_trigger_data_jsont : push_trigger_data Jsont.t
 
 
-type output = {
-  conflicts : conflict_info list option;  (** List of files with merge conflicts *)
-  error : string option;  (** Error message if check failed *)
-  is_conflicted : bool;  (** Whether the merge has conflicts *)
-  message : string option;  (** Additional message about the merge check *)
+type pull_request_trigger_data = {
+  action : string;
+  source_branch : string;
+  source_sha : string;
+  target_branch : string;
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:pull_request_trigger_data}. *)
+val pull_request_trigger_data_jsont : pull_request_trigger_data Jsont.t
 
-      end
-      module Branches : sig
 
-(** Query/procedure parameters. *)
-type params = {
-  cursor : string option;  (** Pagination cursor *)
-  limit : int option;  (** Maximum number of branches to return *)
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+type pair = {
+  key : string;
+  value : string;
+}
+
+(** Jsont codec for {!type:pair}. *)
+val pair_jsont : pair Jsont.t
+
+
+type clone_opts = {
+  depth : int;
+  skip : bool;
+  submodules : bool;
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:clone_opts}. *)
+val clone_opts_jsont : clone_opts Jsont.t
 
 
-type output = unit
-val output_jsont : output Jsont.t
+type workflow = {
+  clone : clone_opts;
+  engine : string;
+  name : string;
+  raw : string;
+}
 
-      end
-      module ForkSync : sig
-(** Sync a forked repository with its upstream source *)
+(** Jsont codec for {!type:workflow}. *)
+val workflow_jsont : workflow Jsont.t
 
 
-type input = {
-  branch : string;  (** Branch to sync *)
-  did : string;  (** DID of the fork owner *)
-  name : string;  (** Name of the forked repository *)
-  source : string;  (** AT-URI of the source repository *)
+type manual_trigger_data = {
+  inputs : pair list option;
 }
 
-(** Jsont codec for {!type:input}. *)
-val input_jsont : input Jsont.t
+(** Jsont codec for {!type:manual_trigger_data}. *)
+val manual_trigger_data_jsont : manual_trigger_data Jsont.t
 
-      end
-      module Languages : sig
 
-type language = {
-  color : string option;  (** Hex color code for this language *)
-  extensions : string list option;  (** File extensions associated with this language *)
-  file_count : int option;  (** Number of files in this language *)
-  name : string;  (** Programming language name *)
-  percentage : int;  (** Percentage of total codebase (0-100) *)
-  size : int;  (** Total size of files in this language (bytes) *)
+type trigger_metadata = {
+  kind : string;
+  manual : manual_trigger_data option;
+  pull_request : pull_request_trigger_data option;
+  push : push_trigger_data option;
+  repo : trigger_repo;
 }
 
-(** Jsont codec for {!type:language}. *)
-val language_jsont : language Jsont.t
+(** Jsont codec for {!type:trigger_metadata}. *)
+val trigger_metadata_jsont : trigger_metadata Jsont.t
 
 
-(** Query/procedure parameters. *)
-type params = {
-  ref_ : string option;  (** Git reference (branch, tag, or commit SHA) *)
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+type main = {
+  trigger_metadata : trigger_metadata;
+  workflows : workflow list;
 }
 
-(** Jsont codec for {!type:params}. *)
-val params_jsont : params Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
+      module Status : sig
 
-type output = {
-  languages : language list;
-  ref_ : string;  (** The git reference used *)
-  total_files : int option;  (** Total number of files analyzed *)
-  total_size : int option;  (** Total size of all analyzed files in bytes *)
+type main = {
+  created_at : string;  (** time of creation of this status update *)
+  error : string option;  (** error message if failed *)
+  exit_code : int option;  (** exit code if failed *)
+  pipeline : string;  (** ATURI of the pipeline *)
+  status : string;  (** status of the workflow *)
+  workflow : string;  (** name of the workflow within this pipeline *)
 }
 
-(** Jsont codec for {!type:output}. *)
-val output_jsont : output Jsont.t
+(** Jsont codec for {!type:main}. *)
+val main_jsont : main Jsont.t
 
       end
     end