switch to jsont for lexicon schema parsing for better errors

atp/lib/blob_ref.mli

···
 (** Jsont codec for blob references.
 
     Encodes as:
-    {v
+{v
 {"$type": "blob", "ref": {"$link": "..."}, "mimeType": "...", "size": ...}
-    v} *)
+v} *)

atp/lib/tid.mli

···
 (** [of_timestamp_us ?clockid us] creates a TID from microsecond timestamp.
 
     @param clockid Clock ID 0-1023 (default: random).
-    @raise Eio.Io if timestamp out of range [0, 2^53) or clockid invalid. *)
+    @raise Eio.Io if timestamp out of range (0 to 2{^53}-1) or clockid invalid. *)
 
 val of_timestamp_ms : ?clockid:int -> int64 -> t
 (** [of_timestamp_ms ?clockid ms] creates a TID from millisecond timestamp.

hermest/bin/dune

···
  (name main)
  (public_name hermest)
  (package hermest-cli)
- (libraries hermest cmdliner))
+ (libraries hermest jsont.bytesrw cmdliner))

hermest/bin/main.ml

···
  (libraries atp jsont jsont.bytesrw))|}
     name public_name_line
 
+(* Parse a lexicon file using jsont *)
+let parse_file path =
+  try
+    let content = In_channel.with_open_bin path In_channel.input_all in
+    match Jsont_bytesrw.decode_string Lexicon_types.lexicon_doc_jsont content with
+    | Ok doc -> Ok doc
+    | Error e -> Error ("JSON decode error: " ^ e)
+  with
+  | Sys_error e -> Error ("File error: " ^ e)
+  | e -> Error ("Unexpected error: " ^ Printexc.to_string e)
+
 (* recursively find all json files in a path (file or directory) *)
 let find_json_files path =
   let rec aux acc p =
···
   let lexicons =
     List.filter_map
       (fun path ->
-        match Parser.parse_file path with
+        match parse_file path with
         | Ok doc ->
             Printf.printf "  Parsed: %s\n" doc.Lexicon_types.id;
             Some doc

hermest/lib/lexicon_types.ml

···
 }
 
 type parse_result = (lexicon_doc, string) result
+
+(* Jsont codecs for all lexicon types *)
+
+let string_spec_jsont : string_spec Jsont.t =
+  let make format min_length max_length min_graphemes max_graphemes known_values
+      enum const default description : string_spec =
+    {
+      format;
+      min_length;
+      max_length;
+      min_graphemes;
+      max_graphemes;
+      known_values;
+      enum;
+      const;
+      default;
+      description;
+    }
+  in
+  let map =
+    Jsont.Object.map ~kind:"string_spec" make
+    |> Jsont.Object.opt_mem "format" Jsont.string
+         ~enc:(fun (s : string_spec) -> s.format)
+    |> Jsont.Object.opt_mem "minLength" Jsont.int
+         ~enc:(fun (s : string_spec) -> s.min_length)
+    |> Jsont.Object.opt_mem "maxLength" Jsont.int
+         ~enc:(fun (s : string_spec) -> s.max_length)
+    |> Jsont.Object.opt_mem "minGraphemes" Jsont.int
+         ~enc:(fun (s : string_spec) -> s.min_graphemes)
+    |> Jsont.Object.opt_mem "maxGraphemes" Jsont.int
+         ~enc:(fun (s : string_spec) -> s.max_graphemes)
+    |> Jsont.Object.opt_mem "knownValues" Jsont.(list string)
+         ~enc:(fun (s : string_spec) -> s.known_values)
+    |> Jsont.Object.opt_mem "enum" Jsont.(list string)
+         ~enc:(fun (s : string_spec) -> s.enum)
+    |> Jsont.Object.opt_mem "const" Jsont.string
+         ~enc:(fun (s : string_spec) -> s.const)
+    |> Jsont.Object.opt_mem "default" Jsont.string
+         ~enc:(fun (s : string_spec) -> s.default)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : string_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let integer_spec_jsont : integer_spec Jsont.t =
+  let make minimum maximum enum const default description : integer_spec =
+    { minimum; maximum; enum; const; default; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"integer_spec" make
+    |> Jsont.Object.opt_mem "minimum" Jsont.int
+         ~enc:(fun (s : integer_spec) -> s.minimum)
+    |> Jsont.Object.opt_mem "maximum" Jsont.int
+         ~enc:(fun (s : integer_spec) -> s.maximum)
+    |> Jsont.Object.opt_mem "enum" Jsont.(list int)
+         ~enc:(fun (s : integer_spec) -> s.enum)
+    |> Jsont.Object.opt_mem "const" Jsont.int
+         ~enc:(fun (s : integer_spec) -> s.const)
+    |> Jsont.Object.opt_mem "default" Jsont.int
+         ~enc:(fun (s : integer_spec) -> s.default)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : integer_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let boolean_spec_jsont : boolean_spec Jsont.t =
+  let make const default description : boolean_spec =
+    { const; default; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"boolean_spec" make
+    |> Jsont.Object.opt_mem "const" Jsont.bool
+         ~enc:(fun (s : boolean_spec) -> s.const)
+    |> Jsont.Object.opt_mem "default" Jsont.bool
+         ~enc:(fun (s : boolean_spec) -> s.default)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : boolean_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let bytes_spec_jsont : bytes_spec Jsont.t =
+  let make min_length max_length description : bytes_spec =
+    { min_length; max_length; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"bytes_spec" make
+    |> Jsont.Object.opt_mem "minLength" Jsont.int
+         ~enc:(fun (s : bytes_spec) -> s.min_length)
+    |> Jsont.Object.opt_mem "maxLength" Jsont.int
+         ~enc:(fun (s : bytes_spec) -> s.max_length)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : bytes_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let blob_spec_jsont : blob_spec Jsont.t =
+  let make accept max_size description : blob_spec =
+    { accept; max_size; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"blob_spec" make
+    |> Jsont.Object.opt_mem "accept" Jsont.(list string)
+         ~enc:(fun (s : blob_spec) -> s.accept)
+    |> Jsont.Object.opt_mem "maxSize" Jsont.int
+         ~enc:(fun (s : blob_spec) -> s.max_size)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : blob_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let cid_link_spec_jsont : cid_link_spec Jsont.t =
+  let make description : cid_link_spec = { description } in
+  let map =
+    Jsont.Object.map ~kind:"cid_link_spec" make
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : cid_link_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let ref_spec_jsont : ref_spec Jsont.t =
+  let make ref_ description : ref_spec = { ref_; description } in
+  let map =
+    Jsont.Object.map ~kind:"ref_spec" make
+    |> Jsont.Object.mem "ref" Jsont.string
+         ~enc:(fun (s : ref_spec) -> s.ref_)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : ref_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let union_spec_jsont : union_spec Jsont.t =
+  let make refs closed description : union_spec = { refs; closed; description } in
+  let map =
+    Jsont.Object.map ~kind:"union_spec" make
+    |> Jsont.Object.mem "refs" Jsont.(list string)
+         ~enc:(fun (s : union_spec) -> s.refs)
+    |> Jsont.Object.opt_mem "closed" Jsont.bool
+         ~enc:(fun (s : union_spec) -> s.closed)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : union_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let token_spec_jsont : token_spec Jsont.t =
+  let make description : token_spec = { description } in
+  let map =
+    Jsont.Object.map ~kind:"token_spec" make
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : token_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let unknown_spec_jsont : unknown_spec Jsont.t =
+  let make description : unknown_spec = { description } in
+  let map =
+    Jsont.Object.map ~kind:"unknown_spec" make
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : unknown_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+let error_def_jsont : error_def Jsont.t =
+  let make name description : error_def = { name; description } in
+  let map =
+    Jsont.Object.map ~kind:"error_def" make
+    |> Jsont.Object.mem "name" Jsont.string
+         ~enc:(fun (s : error_def) -> s.name)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : error_def) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+
+(* Recursive types using Jsont.rec' with lazy values *)
+
+module StringMap = Map.Make(String)
+
+(* Forward declarations for mutually recursive types *)
+let rec type_def_jsont_lazy : type_def Jsont.t Lazy.t = lazy (
+  (* Create case maps for each variant *)
+  let string_case = Jsont.Object.Case.map "string" string_spec_jsont
+      ~dec:(fun s -> String s) in
+  let integer_case = Jsont.Object.Case.map "integer" integer_spec_jsont
+      ~dec:(fun s -> Integer s) in
+  let boolean_case = Jsont.Object.Case.map "boolean" boolean_spec_jsont
+      ~dec:(fun s -> Boolean s) in
+  let bytes_case = Jsont.Object.Case.map "bytes" bytes_spec_jsont
+      ~dec:(fun s -> Bytes s) in
+  let blob_case = Jsont.Object.Case.map "blob" blob_spec_jsont
+      ~dec:(fun s -> Blob s) in
+  let cid_link_case = Jsont.Object.Case.map "cid-link" cid_link_spec_jsont
+      ~dec:(fun s -> CidLink s) in
+  let array_case = Jsont.Object.Case.map "array" (Lazy.force array_spec_jsont_lazy)
+      ~dec:(fun s -> Array s) in
+  let object_case = Jsont.Object.Case.map "object" (Lazy.force object_spec_jsont_lazy)
+      ~dec:(fun s -> Object s) in
+  let ref_case = Jsont.Object.Case.map "ref" ref_spec_jsont
+      ~dec:(fun s -> Ref s) in
+  let union_case = Jsont.Object.Case.map "union" union_spec_jsont
+      ~dec:(fun s -> Union s) in
+  let token_case = Jsont.Object.Case.map "token" token_spec_jsont
+      ~dec:(fun s -> Token s) in
+  let unknown_case = Jsont.Object.Case.map "unknown" unknown_spec_jsont
+      ~dec:(fun s -> Unknown s) in
+  let query_case = Jsont.Object.Case.map "query" (Lazy.force query_spec_jsont_lazy)
+      ~dec:(fun s -> Query s) in
+  let procedure_case = Jsont.Object.Case.map "procedure" (Lazy.force procedure_spec_jsont_lazy)
+      ~dec:(fun s -> Procedure s) in
+  let subscription_case = Jsont.Object.Case.map "subscription" (Lazy.force subscription_spec_jsont_lazy)
+      ~dec:(fun s -> Subscription s) in
+  let record_case = Jsont.Object.Case.map "record" (Lazy.force record_spec_jsont_lazy)
+      ~dec:(fun s -> Record s) in
+  let permission_set_case = Jsont.Object.Case.map "permission-set" (Lazy.force permission_set_spec_jsont_lazy)
+      ~dec:(fun s -> PermissionSet s) in
+  (* Create enc_case function for encoding *)
+  let enc_case = function
+    | String s -> Jsont.Object.Case.value string_case s
+    | Integer s -> Jsont.Object.Case.value integer_case s
+    | Boolean s -> Jsont.Object.Case.value boolean_case s
+    | Bytes s -> Jsont.Object.Case.value bytes_case s
+    | Blob s -> Jsont.Object.Case.value blob_case s
+    | CidLink s -> Jsont.Object.Case.value cid_link_case s
+    | Array s -> Jsont.Object.Case.value array_case s
+    | Object s -> Jsont.Object.Case.value object_case s
+    | Ref s -> Jsont.Object.Case.value ref_case s
+    | Union s -> Jsont.Object.Case.value union_case s
+    | Token s -> Jsont.Object.Case.value token_case s
+    | Unknown s -> Jsont.Object.Case.value unknown_case s
+    | Query s -> Jsont.Object.Case.value query_case s
+    | Procedure s -> Jsont.Object.Case.value procedure_case s
+    | Subscription s -> Jsont.Object.Case.value subscription_case s
+    | Record s -> Jsont.Object.Case.value record_case s
+    | PermissionSet s -> Jsont.Object.Case.value permission_set_case s
+  in
+  (* List of all cases *)
+  let cases = Jsont.Object.Case.[
+    make string_case; make integer_case; make boolean_case; make bytes_case;
+    make blob_case; make cid_link_case; make array_case; make object_case;
+    make ref_case; make union_case; make token_case; make unknown_case;
+    make query_case; make procedure_case; make subscription_case;
+    make record_case; make permission_set_case
+  ] in
+  (* Build the type_def codec *)
+  Jsont.Object.map ~kind:"type_def" Fun.id
+  |> Jsont.Object.case_mem "type" Jsont.string ~enc:Fun.id ~enc_case cases
+  |> Jsont.Object.finish
+)
+
+and property_jsont_lazy : property Jsont.t Lazy.t = lazy (
+  let make type_def description : property = { type_def; description } in
+  let map =
+    Jsont.Object.map ~kind:"property" make
+    |> Jsont.Object.mem "type_def" (Jsont.rec' type_def_jsont_lazy)
+         ~enc:(fun (p : property) -> p.type_def)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (p : property) -> p.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+(* Extract description from a type_def. Each variant's spec contains the description. *)
+and get_type_def_description (td : type_def) : string option =
+  match td with
+  | String s -> s.description
+  | Integer s -> s.description
+  | Boolean s -> s.description
+  | Bytes s -> s.description
+  | Blob s -> s.description
+  | CidLink s -> s.description
+  | Array s -> s.description
+  | Object s -> s.description
+  | Ref s -> s.description
+  | Union s -> s.description
+  | Token s -> s.description
+  | Unknown s -> s.description
+  | Query s -> s.description
+  | Procedure s -> s.description
+  | Subscription s -> s.description
+  | Record s -> s.description
+  | PermissionSet s -> s.description
+
+(* Helper to decode properties object as (string * property) list.
+   Each property value contains type_def fields including description.
+   We decode as type_def and extract the description from it.
+   Note: Field order is alphabetical since JSON object keys have no defined order. *)
+and properties_jsont_lazy : (string * property) list Jsont.t Lazy.t = lazy (
+  let map_jsont = Jsont.Object.as_string_map (Jsont.rec' type_def_jsont_lazy) in
+  Jsont.map
+    ~kind:"properties"
+    ~dec:(fun m ->
+      StringMap.bindings m |> List.map (fun (name, type_def) ->
+        let description = get_type_def_description type_def in
+        (name, { type_def; description })))
+    ~enc:(fun (props : (string * property) list) ->
+      List.fold_left (fun m (name, (prop : property)) ->
+        StringMap.add name prop.type_def m) StringMap.empty props)
+    map_jsont
+)
+
+and object_spec_jsont_lazy : object_spec Jsont.t Lazy.t = lazy (
+  let make properties required nullable description : object_spec =
+    { properties; required; nullable; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"object_spec" make
+    |> Jsont.Object.mem "properties" (Jsont.rec' properties_jsont_lazy)
+         ~dec_absent:[] ~enc:(fun (s : object_spec) -> s.properties)
+    |> Jsont.Object.opt_mem "required" Jsont.(list string)
+         ~enc:(fun (s : object_spec) -> s.required)
+    |> Jsont.Object.opt_mem "nullable" Jsont.(list string)
+         ~enc:(fun (s : object_spec) -> s.nullable)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : object_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and array_spec_jsont_lazy : array_spec Jsont.t Lazy.t = lazy (
+  let make items min_length max_length description : array_spec =
+    { items; min_length; max_length; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"array_spec" make
+    |> Jsont.Object.mem "items" (Jsont.rec' type_def_jsont_lazy)
+         ~enc:(fun (s : array_spec) -> s.items)
+    |> Jsont.Object.opt_mem "minLength" Jsont.int
+         ~enc:(fun (s : array_spec) -> s.min_length)
+    |> Jsont.Object.opt_mem "maxLength" Jsont.int
+         ~enc:(fun (s : array_spec) -> s.max_length)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : array_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and params_spec_jsont_lazy : params_spec Jsont.t Lazy.t = lazy (
+  let make properties required description : params_spec =
+    { properties; required; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"params_spec" make
+    |> Jsont.Object.mem "properties" (Jsont.rec' properties_jsont_lazy)
+         ~dec_absent:[] ~enc:(fun (s : params_spec) -> s.properties)
+    |> Jsont.Object.opt_mem "required" Jsont.(list string)
+         ~enc:(fun (s : params_spec) -> s.required)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : params_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and body_def_jsont_lazy : body_def Jsont.t Lazy.t = lazy (
+  let make encoding schema description : body_def =
+    { encoding; schema; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"body_def" make
+    |> Jsont.Object.mem "encoding" Jsont.string
+         ~enc:(fun (s : body_def) -> s.encoding)
+    |> Jsont.Object.opt_mem "schema" (Jsont.rec' type_def_jsont_lazy)
+         ~enc:(fun (s : body_def) -> s.schema)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : body_def) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and query_spec_jsont_lazy : query_spec Jsont.t Lazy.t = lazy (
+  let make parameters output errors description : query_spec =
+    { parameters; output; errors; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"query_spec" make
+    |> Jsont.Object.opt_mem "parameters" (Jsont.rec' params_spec_jsont_lazy)
+         ~enc:(fun (s : query_spec) -> s.parameters)
+    |> Jsont.Object.opt_mem "output" (Jsont.rec' body_def_jsont_lazy)
+         ~enc:(fun (s : query_spec) -> s.output)
+    |> Jsont.Object.opt_mem "errors" Jsont.(list error_def_jsont)
+         ~enc:(fun (s : query_spec) -> s.errors)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : query_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and procedure_spec_jsont_lazy : procedure_spec Jsont.t Lazy.t = lazy (
+  let make parameters input output errors description : procedure_spec =
+    { parameters; input; output; errors; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"procedure_spec" make
+    |> Jsont.Object.opt_mem "parameters" (Jsont.rec' params_spec_jsont_lazy)
+         ~enc:(fun (s : procedure_spec) -> s.parameters)
+    |> Jsont.Object.opt_mem "input" (Jsont.rec' body_def_jsont_lazy)
+         ~enc:(fun (s : procedure_spec) -> s.input)
+    |> Jsont.Object.opt_mem "output" (Jsont.rec' body_def_jsont_lazy)
+         ~enc:(fun (s : procedure_spec) -> s.output)
+    |> Jsont.Object.opt_mem "errors" Jsont.(list error_def_jsont)
+         ~enc:(fun (s : procedure_spec) -> s.errors)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : procedure_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and subscription_spec_jsont_lazy : subscription_spec Jsont.t Lazy.t = lazy (
+  let make parameters message errors description : subscription_spec =
+    { parameters; message; errors; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"subscription_spec" make
+    |> Jsont.Object.opt_mem "parameters" (Jsont.rec' params_spec_jsont_lazy)
+         ~enc:(fun (s : subscription_spec) -> s.parameters)
+    |> Jsont.Object.opt_mem "message" (Jsont.rec' body_def_jsont_lazy)
+         ~enc:(fun (s : subscription_spec) -> s.message)
+    |> Jsont.Object.opt_mem "errors" Jsont.(list error_def_jsont)
+         ~enc:(fun (s : subscription_spec) -> s.errors)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : subscription_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and record_spec_jsont_lazy : record_spec Jsont.t Lazy.t = lazy (
+  let make key record description : record_spec = { key; record; description } in
+  let map =
+    Jsont.Object.map ~kind:"record_spec" make
+    |> Jsont.Object.mem "key" Jsont.string
+         ~enc:(fun (s : record_spec) -> s.key)
+    |> Jsont.Object.mem "record" (Jsont.rec' object_spec_jsont_lazy)
+         ~enc:(fun (s : record_spec) -> s.record)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : record_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and permission_spec_jsont_lazy : permission_spec Jsont.t Lazy.t = lazy (
+  let make resource inherit_aud lxm action collection : permission_spec =
+    { resource; inherit_aud; lxm; action; collection }
+  in
+  let map =
+    Jsont.Object.map ~kind:"permission_spec" make
+    |> Jsont.Object.mem "resource" Jsont.string
+         ~enc:(fun (s : permission_spec) -> s.resource)
+    |> Jsont.Object.opt_mem "inherit_aud" Jsont.bool
+         ~enc:(fun (s : permission_spec) -> s.inherit_aud)
+    |> Jsont.Object.opt_mem "lxm" Jsont.(list string)
+         ~enc:(fun (s : permission_spec) -> s.lxm)
+    |> Jsont.Object.opt_mem "action" Jsont.(list string)
+         ~enc:(fun (s : permission_spec) -> s.action)
+    |> Jsont.Object.opt_mem "collection" Jsont.(list string)
+         ~enc:(fun (s : permission_spec) -> s.collection)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+and permission_set_spec_jsont_lazy : permission_set_spec Jsont.t Lazy.t = lazy (
+  let make title detail permissions description : permission_set_spec =
+    { title; detail; permissions; description }
+  in
+  let map =
+    Jsont.Object.map ~kind:"permission_set_spec" make
+    |> Jsont.Object.mem "title" Jsont.string
+         ~enc:(fun (s : permission_set_spec) -> s.title)
+    |> Jsont.Object.opt_mem "detail" Jsont.string
+         ~enc:(fun (s : permission_set_spec) -> s.detail)
+    |> Jsont.Object.mem "permissions" Jsont.(list (Jsont.rec' permission_spec_jsont_lazy))
+         ~enc:(fun (s : permission_set_spec) -> s.permissions)
+    |> Jsont.Object.opt_mem "description" Jsont.string
+         ~enc:(fun (s : permission_set_spec) -> s.description)
+    |> Jsont.Object.skip_unknown
+  in
+  Jsont.Object.finish map
+)
+
+(* Force lazy values to get the actual codecs *)
+let type_def_jsont = Lazy.force type_def_jsont_lazy
+let property_jsont = Lazy.force property_jsont_lazy
+let object_spec_jsont = Lazy.force object_spec_jsont_lazy
+let array_spec_jsont = Lazy.force array_spec_jsont_lazy
+let params_spec_jsont = Lazy.force params_spec_jsont_lazy
+let body_def_jsont = Lazy.force body_def_jsont_lazy
+let query_spec_jsont = Lazy.force query_spec_jsont_lazy
+let procedure_spec_jsont = Lazy.force procedure_spec_jsont_lazy
+let subscription_spec_jsont = Lazy.force subscription_spec_jsont_lazy
+let record_spec_jsont = Lazy.force record_spec_jsont_lazy
+
+(* defs_jsont decodes an object {"name": type_def, ...} as a def_entry list *)
+let defs_jsont : def_entry list Jsont.t =
+  (* Decode as a string map of type_def values *)
+  let map_jsont = Jsont.Object.as_string_map type_def_jsont in
+  (* Wrap with conversion functions *)
+  Jsont.map
+    ~kind:"defs"
+    ~dec:(fun m -> StringMap.fold (fun name type_def acc -> { name; type_def } :: acc) m [])
+    ~enc:(fun defs -> List.fold_left (fun m d -> StringMap.add d.name d.type_def m) StringMap.empty defs)
+    map_jsont
+
+let def_entry_jsont : def_entry Jsont.t =
+  let make name type_def = { name; type_def } in
+  Jsont.Object.map ~kind:"def_entry" make
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun s -> s.name)
+  |> Jsont.Object.mem "type_def" type_def_jsont ~enc:(fun s -> s.type_def)
+  |> Jsont.Object.skip_unknown
+  |> Jsont.Object.finish
+
+let lexicon_doc_jsont : lexicon_doc Jsont.t =
+  let make lexicon id revision description defs =
+    { lexicon; id; revision; description; defs }
+  in
+  Jsont.Object.map ~kind:"lexicon_doc" make
+  |> Jsont.Object.mem "lexicon" Jsont.int ~enc:(fun s -> s.lexicon)
+  |> Jsont.Object.mem "id" Jsont.string ~enc:(fun s -> s.id)
+  |> Jsont.Object.opt_mem "revision" Jsont.int ~enc:(fun s -> s.revision)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun s -> s.description)
+  |> Jsont.Object.mem "defs" defs_jsont ~enc:(fun s -> s.defs)
+  |> Jsont.Object.skip_unknown
+  |> Jsont.Object.finish

hermest/lib/lexicon_types.mli

···
 
 type parse_result = (lexicon_doc, string) result
 (** Result of parsing a lexicon JSON file. *)
+
+(** {1 Jsont Codecs}
+
+    These codecs can be used to parse and serialize lexicon documents using the
+    jsont library. *)
+
+val string_spec_jsont : string_spec Jsont.t
+(** JSON codec for string specifications. *)
+
+val integer_spec_jsont : integer_spec Jsont.t
+(** JSON codec for integer specifications. *)
+
+val boolean_spec_jsont : boolean_spec Jsont.t
+(** JSON codec for boolean specifications. *)
+
+val bytes_spec_jsont : bytes_spec Jsont.t
+(** JSON codec for bytes specifications. *)
+
+val blob_spec_jsont : blob_spec Jsont.t
+(** JSON codec for blob specifications. *)
+
+val cid_link_spec_jsont : cid_link_spec Jsont.t
+(** JSON codec for CID link specifications. *)
+
+val ref_spec_jsont : ref_spec Jsont.t
+(** JSON codec for reference specifications. *)
+
+val union_spec_jsont : union_spec Jsont.t
+(** JSON codec for union specifications. *)
+
+val token_spec_jsont : token_spec Jsont.t
+(** JSON codec for token specifications. *)
+
+val unknown_spec_jsont : unknown_spec Jsont.t
+(** JSON codec for unknown type specifications. *)
+
+val error_def_jsont : error_def Jsont.t
+(** JSON codec for error definitions. *)
+
+val type_def_jsont : type_def Jsont.t
+(** JSON codec for type definitions (discriminated union). *)
+
+val property_jsont : property Jsont.t
+(** JSON codec for object properties. *)
+
+val object_spec_jsont : object_spec Jsont.t
+(** JSON codec for object specifications. *)
+
+val array_spec_jsont : array_spec Jsont.t
+(** JSON codec for array specifications. *)
+
+val params_spec_jsont : params_spec Jsont.t
+(** JSON codec for parameter specifications. *)
+
+val body_def_jsont : body_def Jsont.t
+(** JSON codec for body definitions. *)
+
+val query_spec_jsont : query_spec Jsont.t
+(** JSON codec for query specifications. *)
+
+val procedure_spec_jsont : procedure_spec Jsont.t
+(** JSON codec for procedure specifications. *)
+
+val subscription_spec_jsont : subscription_spec Jsont.t
+(** JSON codec for subscription specifications. *)
+
+val record_spec_jsont : record_spec Jsont.t
+(** JSON codec for record specifications. *)
+
+val def_entry_jsont : def_entry Jsont.t
+(** JSON codec for definition entries. *)
+
+val lexicon_doc_jsont : lexicon_doc Jsont.t
+(** JSON codec for lexicon documents. *)

hermest/lib/parser.ml

···
-(* This Source Code Form is subject to the terms of the Mozilla Public
-   License, v. 2.0. If a copy of the MPL was not distributed with this
-   file, You can obtain one at http://mozilla.org/MPL/2.0/. *)
-
-(* parse lexicon json files into lexicon_types using jsont *)
-
-open Lexicon_types
-
-(* Helper to get object members as association list *)
-let get_members = function
-  | Jsont.Object (mems, _) ->
-      Some (List.map (fun ((name, _), value) -> (name, value)) mems)
-  | _ -> None
-
-(* Generic field extractor using Option.bind *)
-let get_field extract key json =
-  Option.bind (get_members json) (fun pairs ->
-      Option.bind (List.assoc_opt key pairs) extract)
-
-let get_string_opt key =
-  get_field (function Jsont.String (s, _) -> Some s | _ -> None) key
-
-let get_int_opt key =
-  get_field
-    (function Jsont.Number (f, _) -> Some (int_of_float f) | _ -> None)
-    key
-
-let get_bool_opt key =
-  get_field (function Jsont.Bool (b, _) -> Some b | _ -> None) key
-
-let get_list_opt key =
-  get_field (function Jsont.Array (l, _) -> Some l | _ -> None) key
-
-let get_string key json =
-  match get_string_opt key json with
-  | Some s -> s
-  | None -> failwith ("missing required string field: " ^ key)
-
-let get_int key json =
-  match get_int_opt key json with
-  | Some i -> i
-  | None -> failwith ("missing required int field: " ^ key)
-
-let get_string_list_opt key json =
-  Option.map
-    (List.filter_map (function Jsont.String (s, _) -> Some s | _ -> None))
-    (get_list_opt key json)
-
-let get_int_list_opt key json =
-  Option.map
-    (List.filter_map (function
-      | Jsont.Number (f, _) -> Some (int_of_float f)
-      | _ -> None))
-    (get_list_opt key json)
-
-let get_assoc key json =
-  match get_members json with
-  | Some pairs -> (
-      match List.assoc_opt key pairs with
-      | Some (Jsont.Object _ as a) -> Some a
-      | _ -> None)
-  | None -> None
-
-(* parse type definition from json *)
-let rec parse_type_def json : type_def =
-  let type_str = get_string "type" json in
-  match type_str with
-  | "string" ->
-      String
-        {
-          format = get_string_opt "format" json;
-          min_length = get_int_opt "minLength" json;
-          max_length = get_int_opt "maxLength" json;
-          min_graphemes = get_int_opt "minGraphemes" json;
-          max_graphemes = get_int_opt "maxGraphemes" json;
-          known_values = get_string_list_opt "knownValues" json;
-          enum = get_string_list_opt "enum" json;
-          const = get_string_opt "const" json;
-          default = get_string_opt "default" json;
-          description = get_string_opt "description" json;
-        }
-  | "integer" ->
-      Integer
-        {
-          minimum = get_int_opt "minimum" json;
-          maximum = get_int_opt "maximum" json;
-          enum = get_int_list_opt "enum" json;
-          const = get_int_opt "const" json;
-          default = get_int_opt "default" json;
-          description = get_string_opt "description" json;
-        }
-  | "boolean" ->
-      Boolean
-        {
-          const = get_bool_opt "const" json;
-          default = get_bool_opt "default" json;
-          description = get_string_opt "description" json;
-        }
-  | "bytes" ->
-      Bytes
-        {
-          min_length = get_int_opt "minLength" json;
-          max_length = get_int_opt "maxLength" json;
-          description = get_string_opt "description" json;
-        }
-  | "blob" ->
-      Blob
-        {
-          accept = get_string_list_opt "accept" json;
-          max_size = get_int_opt "maxSize" json;
-          description = get_string_opt "description" json;
-        }
-  | "cid-link" -> CidLink { description = get_string_opt "description" json }
-  | "array" ->
-      let items_json =
-        match get_assoc "items" json with
-        | Some j -> j
-        | None -> failwith "array type missing items"
-      in
-      Array
-        {
-          items = parse_type_def items_json;
-          min_length = get_int_opt "minLength" json;
-          max_length = get_int_opt "maxLength" json;
-          description = get_string_opt "description" json;
-        }
-  | "object" -> Object (parse_object_spec json)
-  | "ref" ->
-      Ref
-        {
-          ref_ = get_string "ref" json;
-          description = get_string_opt "description" json;
-        }
-  | "union" ->
-      Union
-        {
-          refs =
-            (match get_string_list_opt "refs" json with
-            | Some l -> l
-            | None -> []);
-          closed = get_bool_opt "closed" json;
-          description = get_string_opt "description" json;
-        }
-  | "token" -> Token { description = get_string_opt "description" json }
-  | "unknown" -> Unknown { description = get_string_opt "description" json }
-  | "query" -> Query (parse_query_spec json)
-  | "procedure" -> Procedure (parse_procedure_spec json)
-  | "subscription" -> Subscription (parse_subscription_spec json)
-  | "record" -> Record (parse_record_spec json)
-  | "permission-set" -> PermissionSet (parse_permission_set_spec json)
-  | "params" ->
-      (* params type used in query/procedure parameters *)
-      Object (parse_object_spec json)
-  | t -> failwith ("unknown type: " ^ t)
-
-and parse_object_spec json : object_spec =
-  let properties =
-    match get_assoc "properties" json with
-    | Some obj -> (
-        match get_members obj with
-        | Some pairs ->
-            List.map
-              (fun (name, prop_json) ->
-                let type_def = parse_type_def prop_json in
-                let description = get_string_opt "description" prop_json in
-                (name, { type_def; description }))
-              pairs
-        | None -> [])
-    | _ -> []
-  in
-  {
-    properties;
-    required = get_string_list_opt "required" json;
-    nullable = get_string_list_opt "nullable" json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_params_spec json : params_spec =
-  let properties =
-    match get_assoc "properties" json with
-    | Some obj -> (
-        match get_members obj with
-        | Some pairs ->
-            List.map
-              (fun (name, prop_json) ->
-                let type_def = parse_type_def prop_json in
-                let description = get_string_opt "description" prop_json in
-                (name, { type_def; description }))
-              pairs
-        | None -> [])
-    | _ -> []
-  in
-  {
-    properties;
-    required = get_string_list_opt "required" json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_body_def json : body_def =
-  {
-    encoding = get_string "encoding" json;
-    schema = Option.map parse_type_def (get_assoc "schema" json);
-    description = get_string_opt "description" json;
-  }
-
-and parse_error_def json : error_def =
-  {
-    name = get_string "name" json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_errors_opt json =
-  Option.map
-    (List.map (function
-      | Jsont.Object _ as j -> parse_error_def j
-      | _ -> failwith "invalid error def"))
-    (get_list_opt "errors" json)
-
-and parse_query_spec json : query_spec =
-  {
-    parameters = Option.map parse_params_spec (get_assoc "parameters" json);
-    output = Option.map parse_body_def (get_assoc "output" json);
-    errors = parse_errors_opt json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_procedure_spec json : procedure_spec =
-  {
-    parameters = Option.map parse_params_spec (get_assoc "parameters" json);
-    input = Option.map parse_body_def (get_assoc "input" json);
-    output = Option.map parse_body_def (get_assoc "output" json);
-    errors = parse_errors_opt json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_subscription_spec json : subscription_spec =
-  {
-    parameters = Option.map parse_params_spec (get_assoc "parameters" json);
-    message = Option.map parse_body_def (get_assoc "message" json);
-    errors = parse_errors_opt json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_record_spec json : record_spec =
-  let key = get_string "key" json in
-  let record_json =
-    match get_assoc "record" json with
-    | Some j -> j
-    | None -> failwith "record type missing record field"
-  in
-  {
-    key;
-    record = parse_object_spec record_json;
-    description = get_string_opt "description" json;
-  }
-
-and parse_permission_spec json : permission_spec =
-  {
-    resource = get_string "resource" json;
-    inherit_aud = get_bool_opt "inheritAud" json;
-    lxm = get_string_list_opt "lxm" json;
-    action = get_string_list_opt "action" json;
-    collection = get_string_list_opt "collection" json;
-  }
-
-and parse_permission_set_spec json : permission_set_spec =
-  let permissions =
-    match get_list_opt "permissions" json with
-    | Some perms ->
-        List.filter_map
-          (function Jsont.Object _ as j -> Some (parse_permission_spec j) | _ -> None)
-          perms
-    | None -> []
-  in
-  {
-    title = get_string "title" json;
-    detail = get_string_opt "detail" json;
-    permissions;
-    description = get_string_opt "description" json;
-  }
-
-(* parse complete lexicon document *)
-let parse_lexicon_doc json : lexicon_doc =
-  let lexicon = get_int "lexicon" json in
-  let id = get_string "id" json in
-  let revision = get_int_opt "revision" json in
-  let description = get_string_opt "description" json in
-  let defs =
-    match get_assoc "defs" json with
-    | Some obj -> (
-        match get_members obj with
-        | Some pairs ->
-            List.map
-              (fun (name, def_json) -> { name; type_def = parse_type_def def_json })
-              pairs
-        | None -> [])
-    | _ -> []
-  in
-  { lexicon; id; revision; description; defs }
-
-(* parse lexicon file *)
-let parse_file path : parse_result =
-  try
-    let content = In_channel.with_open_bin path In_channel.input_all in
-    match Jsont_bytesrw.decode_string Jsont.json content with
-    | Ok json -> Ok (parse_lexicon_doc json)
-    | Error e -> Error ("JSON parse error: " ^ e)
-  with
-  | Failure e -> Error ("Parse error: " ^ e)
-  | e -> Error ("Unexpected error: " ^ Printexc.to_string e)
-
-(* parse json string *)
-let parse_string content : parse_result =
-  try
-    match Jsont_bytesrw.decode_string Jsont.json content with
-    | Ok json -> Ok (parse_lexicon_doc json)
-    | Error e -> Error ("JSON parse error: " ^ e)
-  with
-  | Failure e -> Error ("Parse error: " ^ e)
-  | e -> Error ("Unexpected error: " ^ Printexc.to_string e)

hermest/lib/parser.mli

···
-(* This Source Code Form is subject to the terms of the Mozilla Public
-   License, v. 2.0. If a copy of the MPL was not distributed with this
-   file, You can obtain one at http://mozilla.org/MPL/2.0/. *)
-
-(** AT Protocol Lexicon JSON parser.
-
-    This module parses lexicon JSON files into {!Lexicon_types.lexicon_doc}
-    structures. Lexicons are typically stored as JSON files with the [.json]
-    extension.
-
-    {2 Usage}
-
-    {[
-      match Parser.parse_file "app.bsky.feed.post.json" with
-      | Ok doc -> Printf.printf "Parsed lexicon: %s\n" doc.id
-      | Error msg -> Printf.eprintf "Error: %s\n" msg
-    ]} *)
-
-val parse_file : string -> Lexicon_types.parse_result
-(** [parse_file path] parses a lexicon JSON file at [path].
-
-    Returns [Ok doc] on success or [Error msg] with a descriptive error message
-    on failure. *)
-
-val parse_string : string -> Lexicon_types.parse_result
-(** [parse_string content] parses lexicon JSON from a string.
-
-    Returns [Ok doc] on success or [Error msg] with a descriptive error message
-    on failure. *)

lexicons/atproto/atp_lexicon_atproto.ml

···
     module Repo = struct
       module StrongRef = struct
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ uri cid -> { uri; cid })
+    (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.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.finish
 
       end
···
       end
       module ListRecords = struct
 type record = {
-  uri : string;
   cid : string;
+  uri : string;
   value : Jsont.json;
 }
 
 let record_jsont =
   Jsont.Object.map ~kind:"Record"
-    (fun _typ uri cid value -> { uri; cid; value })
+    (fun _typ cid uri value -> { cid; uri; value })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.listRecords#record" ~enc:(fun _ -> "com.atproto.repo.listRecords#record")
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
 type params = {
-  repo : string;
   collection : string;
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  repo : string;
   reverse : bool option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo collection limit cursor reverse -> {
-      repo;
+    (fun collection cursor limit repo reverse -> {
       collection;
+      cursor;
       limit;
-      cursor;
+      repo;
       reverse;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
   |> Jsont.Object.mem "collection" Jsont.string
        ~enc:(fun r -> r.collection)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
   |> Jsont.Object.opt_mem "reverse" Jsont.bool
        ~enc:(fun r -> r.reverse)
   |> Jsont.Object.finish
···
       end
       module GetRecord = struct
 type params = {
+  cid : string option;
+  collection : string;
   repo : string;
-  collection : string;
   rkey : string;
-  cid : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo collection rkey cid -> {
+    (fun cid collection repo rkey -> {
+      cid;
+      collection;
       repo;
-      collection;
       rkey;
-      cid;
     })
+  |> 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 "collection" Jsont.string
-       ~enc:(fun r -> r.collection)
   |> Jsont.Object.mem "rkey" Jsont.string
        ~enc:(fun r -> r.rkey)
-  |> Jsont.Object.opt_mem "cid" Jsont.string
-       ~enc:(fun r -> r.cid)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string option;
+  uri : string;
   value : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid value -> { uri; cid; value })
+    (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.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
       end
       module PutRecord = struct
 type input = {
-  repo : string;
   collection : string;
+  record : Jsont.json;
+  repo : string;
   rkey : string;
-  validate : bool option;
-  record : Jsont.json;
+  swap_commit : string option;
   swap_record : string option;
-  swap_commit : string option;
+  validate : bool option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo collection rkey validate record swap_record swap_commit -> { repo; collection; rkey; validate; record; swap_record; swap_commit })
+    (fun _typ collection record repo rkey swap_commit swap_record validate -> { collection; record; repo; rkey; swap_commit; swap_record; validate })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.putRecord#input" ~enc:(fun _ -> "com.atproto.repo.putRecord#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 "collection" Jsont.string ~enc:(fun r -> r.collection)
   |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
-  |> Jsont.Object.opt_mem "validate" Jsont.bool ~enc:(fun r -> r.validate)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> 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 "swapCommit" Jsont.string ~enc:(fun r -> r.swap_commit)
+  |> Jsont.Object.opt_mem "validate" Jsont.bool ~enc:(fun r -> r.validate)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
   validation_status : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid commit validation_status -> { uri; cid; commit; validation_status })
+    (fun _typ cid commit uri validation_status -> { cid; commit; uri; validation_status })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.repo.putRecord#output" ~enc:(fun _ -> "com.atproto.repo.putRecord#output")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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
       module DeleteRecord = struct
 type input = {
-  repo : string;
   collection : string;
+  repo : string;
   rkey : string;
-  swap_record : string option;
   swap_commit : string option;
+  swap_record : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo collection rkey swap_record swap_commit -> { repo; collection; rkey; swap_record; swap_commit })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "collection" Jsont.string ~enc:(fun r -> r.collection)
   |> 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 "swapRecord" Jsont.string ~enc:(fun r -> r.swap_record)
-  |> Jsont.Object.opt_mem "swapCommit" Jsont.string ~enc:(fun r -> r.swap_commit)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module CreateRecord = struct
 type input = {
-  repo : string;
   collection : string;
+  record : Jsont.json;
+  repo : string;
   rkey : string option;
+  swap_commit : string option;
   validate : bool option;
-  record : Jsont.json;
-  swap_commit : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo collection rkey validate record swap_commit -> { repo; collection; rkey; validate; record; swap_commit })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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.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.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.opt_mem "swapCommit" Jsont.string ~enc:(fun r -> r.swap_commit)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
   validation_status : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid commit validation_status -> { uri; cid; commit; validation_status })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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
 

lexicons/atproto/atp_lexicon_atproto.mli

···
       module StrongRef : sig
 
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module ListRecords : sig
 
 type record = {
-  uri : string;
   cid : string;
+  uri : string;
   value : Jsont.json;
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** The handle or DID of the repo. *)
   collection : string;  (** The NSID of the record type. *)
+  cursor : string option;
   limit : int option;  (** The number of records to return. *)
-  cursor : string option;
+  repo : string;  (** The handle or DID of the repo. *)
   reverse : bool option;  (** Flag to reverse the order of the returned records. *)
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** The handle or DID of the repo. *)
+  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. *)
-  cid : string option;  (** The CID of the version of the record. If not specified, then return the most recent version. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  uri : string;
   cid : string option;
+  uri : string;
   value : Jsont.json;
 }
 
···
 
 
 type input = {
-  repo : string;  (** The handle or DID of the repo (aka, current account). *)
   collection : string;  (** The NSID of the record collection. *)
-  rkey : string;  (** The Record Key. *)
-  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. *)
   record : Jsont.json;  (** The record to write. *)
-  swap_record : string option;  (** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation *)
+  repo : string;  (** The handle or DID of the repo (aka, current account). *)
+  rkey : string;  (** 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. WARNING: nullable and optional field; may cause problems with golang implementation *)
+  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 = {
-  uri : string;
   cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
   validation_status : string option;
 }
 
···
 
 
 type input = {
-  repo : string;  (** The handle or DID of the repo (aka, current account). *)
   collection : string;  (** The NSID of the record collection. *)
+  repo : string;  (** The handle or DID of the repo (aka, current account). *)
   rkey : string;  (** The Record Key. *)
-  swap_record : string option;  (** Compare and swap with the previous record by CID. *)
   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. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type input = {
-  repo : string;  (** The handle or DID of the repo (aka, current account). *)
   collection : string;  (** The NSID of the record collection. *)
-  rkey : string option;  (** The Record Key. *)
-  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. *)
   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. *)
   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. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
-  uri : string;
   cid : string;
   commit : Defs.commit_meta option;
+  uri : string;
   validation_status : string option;
 }
 

lexicons/bsky/atp_lexicon_bsky.ml

···
   module Atproto = struct
     module Label = struct
       module Defs = struct
-type label = {
-  ver : int option;
-  src : string;
-  uri : string;
-  cid : string option;
-  val_ : string;
-  neg : bool option;
-  cts : string;
-  exp : string option;
-  sig_ : string option;
-}
-
-let label_jsont =
-  Jsont.Object.map ~kind:"Label"
-    (fun _typ ver src uri cid val_ neg cts exp sig_ -> { ver; src; uri; cid; val_; neg; cts; exp; sig_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.label.defs#label" ~enc:(fun _ -> "com.atproto.label.defs#label")
-  |> Jsont.Object.opt_mem "ver" Jsont.int ~enc:(fun r -> r.ver)
-  |> Jsont.Object.mem "src" Jsont.string ~enc:(fun r -> r.src)
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "val" Jsont.string ~enc:(fun r -> r.val_)
-  |> Jsont.Object.opt_mem "neg" Jsont.bool ~enc:(fun r -> r.neg)
-  |> Jsont.Object.mem "cts" Jsont.string ~enc:(fun r -> r.cts)
-  |> Jsont.Object.opt_mem "exp" Jsont.string ~enc:(fun r -> r.exp)
-  |> Jsont.Object.opt_mem "sig" Jsont.binary_string ~enc:(fun r -> r.sig_)
-  |> Jsont.Object.finish
-
 type self_label = {
   val_ : string;
 }
···
   |> Jsont.Object.finish
 
 type label_value_definition_strings = {
+  description : string;
   lang : string;
   name : string;
-  description : string;
 }
 
 let label_value_definition_strings_jsont =
   Jsont.Object.map ~kind:"Label_value_definition_strings"
-    (fun _typ lang name description -> { lang; name; description })
+    (fun _typ description lang name -> { description; lang; name })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.label.defs#labelValueDefinitionStrings" ~enc:(fun _ -> "com.atproto.label.defs#labelValueDefinitionStrings")
+  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
   |> Jsont.Object.mem "lang" Jsont.string ~enc:(fun r -> r.lang)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
   |> Jsont.Object.finish
 
 type label_value = string
 let label_value_jsont = Jsont.string
 
+type label = {
+  cid : string option;
+  cts : string;
+  exp : string option;
+  neg : bool option;
+  sig_ : string option;
+  src : string;
+  uri : string;
+  val_ : string;
+  ver : int option;
+}
+
+let label_jsont =
+  Jsont.Object.map ~kind:"Label"
+    (fun _typ cid cts exp neg sig_ src uri val_ ver -> { cid; cts; exp; neg; sig_; src; uri; val_; ver })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.label.defs#label" ~enc:(fun _ -> "com.atproto.label.defs#label")
+  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.mem "cts" Jsont.string ~enc:(fun r -> r.cts)
+  |> Jsont.Object.opt_mem "exp" Jsont.string ~enc:(fun r -> r.exp)
+  |> Jsont.Object.opt_mem "neg" Jsont.bool ~enc:(fun r -> r.neg)
+  |> Jsont.Object.opt_mem "sig" Jsont.binary_string ~enc:(fun r -> r.sig_)
+  |> Jsont.Object.mem "src" Jsont.string ~enc:(fun r -> r.src)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "val" Jsont.string ~enc:(fun r -> r.val_)
+  |> Jsont.Object.opt_mem "ver" Jsont.int ~enc:(fun r -> r.ver)
+  |> Jsont.Object.finish
+
 type self_labels = {
   values : self_label list;
 }
···
   |> Jsont.Object.finish
 
 type label_value_definition = {
-  identifier : string;
-  severity : string;
+  adult_only : bool option;
   blurs : string;
   default_setting : string option;
-  adult_only : bool option;
+  identifier : string;
   locales : label_value_definition_strings list;
+  severity : string;
 }
 
 let label_value_definition_jsont =
   Jsont.Object.map ~kind:"Label_value_definition"
-    (fun _typ identifier severity blurs default_setting adult_only locales -> { identifier; severity; blurs; default_setting; adult_only; locales })
+    (fun _typ adult_only blurs default_setting identifier locales severity -> { adult_only; blurs; default_setting; identifier; locales; severity })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"com.atproto.label.defs#labelValueDefinition" ~enc:(fun _ -> "com.atproto.label.defs#labelValueDefinition")
-  |> Jsont.Object.mem "identifier" Jsont.string ~enc:(fun r -> r.identifier)
-  |> Jsont.Object.mem "severity" Jsont.string ~enc:(fun r -> r.severity)
+  |> Jsont.Object.opt_mem "adultOnly" Jsont.bool ~enc:(fun r -> r.adult_only)
   |> Jsont.Object.mem "blurs" Jsont.string ~enc:(fun r -> r.blurs)
   |> Jsont.Object.opt_mem "defaultSetting" Jsont.string ~enc:(fun r -> r.default_setting)
-  |> Jsont.Object.opt_mem "adultOnly" Jsont.bool ~enc:(fun r -> r.adult_only)
+  |> Jsont.Object.mem "identifier" Jsont.string ~enc:(fun r -> r.identifier)
   |> Jsont.Object.mem "locales" (Jsont.list label_value_definition_strings_jsont) ~enc:(fun r -> r.locales)
+  |> Jsont.Object.mem "severity" Jsont.string ~enc:(fun r -> r.severity)
   |> Jsont.Object.finish
 
       end
···
     module Repo = struct
       module StrongRef = struct
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ uri cid -> { uri; cid })
+    (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.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.finish
 
       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_violation = string
-let reason_violation_jsont = Jsont.string
-
-type reason_misleading = string
-let reason_misleading_jsont = Jsont.string
-
 type reason_sexual = string
 let reason_sexual_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
-
-type subject_type = string
-let subject_type_jsont = Jsont.string
 
       end
     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;
 }
···
     (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 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 byte_slice = {
-  byte_start : int;
   byte_end : int;
+  byte_start : int;
 }
 
 let byte_slice_jsont =
   Jsont.Object.map ~kind:"Byte_slice"
-    (fun _typ byte_start byte_end -> { byte_start; byte_end })
+    (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.mem "byteEnd" Jsont.int ~enc:(fun r -> r.byte_end)
   |> Jsont.Object.finish
 
 type main = {
-  index : byte_slice;
   features : Jsont.json list;
+  index : byte_slice;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ index features -> { index; features })
+    (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.mem "features" (Jsont.list Jsont.json) ~enc:(fun r -> r.features)
   |> Jsont.Object.finish
 
       end
···
     end
     module Ageassurance = struct
       module Defs = struct
-type access = string
-let access_jsont = Jsont.string
-
 type status = string
 let status_jsont = Jsont.string
 
···
   |> Jsont.Object.opt_mem "accountCreatedAt" Jsont.string ~enc:(fun r -> r.account_created_at)
   |> Jsont.Object.finish
 
-type config_region = {
-  country_code : string;
-  region_code : string option;
-  min_access_age : int;
-  rules : Jsont.json list;
-}
-
-let config_region_jsont =
-  Jsont.Object.map ~kind:"Config_region"
-    (fun _typ country_code region_code min_access_age rules -> { country_code; region_code; min_access_age; 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.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_code)
-  |> Jsont.Object.mem "minAccessAge" Jsont.int ~enc:(fun r -> r.min_access_age)
-  |> Jsont.Object.mem "rules" (Jsont.list Jsont.json) ~enc:(fun r -> r.rules)
-  |> Jsont.Object.finish
-
 type event = {
-  created_at : string;
+  access : string;
   attempt_id : string;
-  status : string;
-  access : string;
+  complete_ip : string option;
+  complete_ua : string option;
   country_code : string;
-  region_code : string option;
+  created_at : string;
   email : string option;
   init_ip : string option;
   init_ua : string option;
-  complete_ip : string option;
-  complete_ua : string option;
+  region_code : string option;
+  status : string;
 }
 
 let event_jsont =
   Jsont.Object.map ~kind:"Event"
-    (fun _typ created_at attempt_id status access country_code region_code email init_ip init_ua complete_ip complete_ua -> { created_at; attempt_id; status; access; country_code; region_code; email; init_ip; init_ua; complete_ip; complete_ua })
+    (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 "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "attemptId" Jsont.string ~enc:(fun r -> r.attempt_id)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
   |> 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.opt_mem "regionCode" Jsont.string ~enc:(fun r -> r.region_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 "completeIp" Jsont.string ~enc:(fun r -> r.complete_ip)
-  |> Jsont.Object.opt_mem "completeUa" Jsont.string ~enc:(fun r -> r.complete_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;
-  access : access;
 }
 
 let state_jsont =
   Jsont.Object.map ~kind:"State"
-    (fun _typ last_initiated_at status access -> { last_initiated_at; status; access })
+    (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.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
-
-type config_region_rule_default = {
+type config_region_rule_if_declared_under_age = {
   access : access;
+  age : int;
 }
 
-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")
+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 = {
-  age : int;
   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 age access -> { age; access })
+    (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.mem "access" access_jsont ~enc:(fun r -> r.access)
   |> Jsont.Object.finish
 
-type config_region_rule_if_declared_under_age = {
-  age : int;
+type config_region_rule_if_assured_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 age access -> { age; access })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge")
+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.mem "access" access_jsont ~enc:(fun r -> r.access)
   |> Jsont.Object.finish
 
 type config_region_rule_if_assured_over_age = {
-  age : int;
   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 age access -> { age; access })
+    (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 "age" Jsont.int ~enc:(fun r -> r.age)
   |> 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 = {
-  age : int;
+type config_region_rule_if_account_older_than = {
   access : access;
+  date : string;
 }
 
-let config_region_rule_if_assured_under_age_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_assured_under_age"
-    (fun _typ age access -> { age; access })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge")
-  |> Jsont.Object.mem "age" Jsont.int ~enc:(fun r -> r.age)
+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;
-  access : access;
 }
 
 let config_region_rule_if_account_newer_than_jsont =
   Jsont.Object.map ~kind:"Config_region_rule_if_account_newer_than"
-    (fun _typ date access -> { date; access })
+    (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 "date" Jsont.string ~enc:(fun r -> r.date)
   |> 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_older_than = {
-  date : string;
+type config_region_rule_default = {
   access : access;
 }
 
-let config_region_rule_if_account_older_than_jsont =
-  Jsont.Object.map ~kind:"Config_region_rule_if_account_older_than"
-    (fun _typ date access -> { date; access })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan" ~enc:(fun _ -> "app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan")
-  |> Jsont.Object.mem "date" Jsont.string ~enc:(fun r -> r.date)
+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;
-  country_code : string;
   region_code : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ email language country_code region_code -> { email; language; country_code; region_code })
+    (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.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
 
···
   |> Jsont.Object.finish
 
 type output = {
-  state : Defs.state;
   metadata : Defs.state_metadata;
+  state : Defs.state;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ state metadata -> { state; metadata })
+    (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 "state" Defs.state_jsont ~enc:(fun r -> r.state)
   |> 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
···
   |> Jsont.Object.finish
 
 type labeler_policies = {
-  label_values : Com.Atproto.Label.Defs.label_value list;
   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_values label_value_definitions -> { label_values; label_value_definitions })
+    (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.opt_mem "labelValueDefinitions" (Jsont.list Com.Atproto.Label.Defs.label_value_definition_jsont) ~enc:(fun r -> r.label_value_definitions)
   |> Jsont.Object.finish
 
-type labeler_view = {
-  uri : string;
+type labeler_view_detailed = {
   cid : string;
   creator : Jsont.json;
-  like_count : int option;
-  viewer : Jsont.json option;
   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_jsont =
-  Jsont.Object.map ~kind:"Labeler_view"
-    (fun _typ uri cid creator like_count viewer indexed_at labels -> { uri; cid; creator; like_count; viewer; indexed_at; labels })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerView" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerView")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+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.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.finish
 
-type labeler_view_detailed = {
-  uri : string;
+type labeler_view = {
   cid : string;
   creator : Jsont.json;
-  policies : Jsont.json;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
   like_count : int option;
+  uri : string;
   viewer : Jsont.json option;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
-  reason_types : Com.Atproto.Moderation.Defs.reason_type list option;
-  subject_types : Com.Atproto.Moderation.Defs.subject_type list option;
-  subject_collections : string list option;
 }
 
-let labeler_view_detailed_jsont =
-  Jsont.Object.map ~kind:"Labeler_view_detailed"
-    (fun _typ uri cid creator policies like_count viewer indexed_at labels reason_types subject_types subject_collections -> { uri; cid; creator; policies; like_count; viewer; indexed_at; labels; reason_types; subject_types; subject_collections })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.labeler.defs#labelerViewDetailed" ~enc:(fun _ -> "app.bsky.labeler.defs#labelerViewDetailed")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+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 "policies" Jsont.json ~enc:(fun r -> r.policies)
+  |> 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.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 "reasonTypes" (Jsont.list Com.Atproto.Moderation.Defs.reason_type_jsont) ~enc:(fun r -> r.reason_types)
-  |> Jsont.Object.opt_mem "subjectTypes" (Jsont.list Com.Atproto.Moderation.Defs.subject_type_jsont) ~enc:(fun r -> r.subject_types)
-  |> Jsont.Object.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
   |> Jsont.Object.finish
 
       end
       module Service = struct
 type main = {
+  created_at : string;
+  labels : Com.Atproto.Label.Defs.self_labels option;
   policies : Jsont.json;
-  labels : Com.Atproto.Label.Defs.self_labels option;
-  created_at : string;
   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;
-  subject_collections : string list option;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ policies labels created_at reason_types subject_types subject_collections -> { policies; labels; created_at; reason_types; subject_types; subject_collections })
+    (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 "policies" Jsont.json ~enc:(fun r -> r.policies)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
   |> 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.opt_mem "subjectCollections" (Jsont.list Jsont.string) ~enc:(fun r -> r.subject_collections)
   |> Jsont.Object.finish
 
       end
       module GetServices = struct
 type params = {
-  dids : string list;
   detailed : bool option;
+  dids : string list;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun dids detailed -> {
-      dids;
+    (fun detailed dids -> {
       detailed;
+      dids;
     })
-  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.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 = {
···
       module GetUploadLimits = struct
 type output = {
   can_upload : bool;
-  remaining_daily_videos : int option;
-  remaining_daily_bytes : int option;
-  message : string option;
   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 remaining_daily_videos remaining_daily_bytes message error -> { can_upload; remaining_daily_videos; remaining_daily_bytes; message; error })
+    (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 "remainingDailyVideos" Jsont.int ~enc:(fun r -> r.remaining_daily_videos)
-  |> Jsont.Object.opt_mem "remainingDailyBytes" Jsont.int ~enc:(fun r -> r.remaining_daily_bytes)
-  |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
   |> 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 = {
-  job_id : string;
+  blob : Atp.Blob_ref.t option;
   did : string;
-  state : string;
-  progress : int option;
-  blob : Atp.Blob_ref.t option;
   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 job_id did state progress blob error message -> { job_id; did; state; progress; blob; error; message })
+    (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.mem "jobId" Jsont.string ~enc:(fun r -> r.job_id)
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
-  |> Jsont.Object.opt_mem "progress" Jsont.int ~enc:(fun r -> r.progress)
   |> 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
···
     end
     module Embed = struct
       module External = struct
-type external_ = {
-  uri : string;
-  title : string;
-  description : string;
-  thumb : Atp.Blob_ref.t option;
-}
-
-let external__jsont =
-  Jsont.Object.map ~kind:"External_"
-    (fun _typ uri title description thumb -> { uri; title; description; thumb })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.external#external" ~enc:(fun _ -> "app.bsky.embed.external#external")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
-  |> 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.finish
-
 type view_external = {
-  uri : string;
-  title : string;
   description : string;
   thumb : string option;
+  title : string;
+  uri : string;
 }
 
 let view_external_jsont =
   Jsont.Object.map ~kind:"View_external"
-    (fun _typ uri title description thumb -> { uri; title; description; thumb })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
   |> 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 main = {
-  external_ : Jsont.json;
+type external_ = {
+  description : string;
+  thumb : Atp.Blob_ref.t option;
+  title : string;
+  uri : 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 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 = {
···
   |> 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;
-  height : int;
 }
 
 let aspect_ratio_jsont =
   Jsont.Object.map ~kind:"Aspect_ratio"
-    (fun _typ width height -> { width; height })
+    (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.mem "height" Jsont.int ~enc:(fun r -> r.height)
   |> Jsont.Object.finish
 
       end
       module Images = struct
-type image = {
-  image : Atp.Blob_ref.t;
+type view_image = {
   alt : string;
   aspect_ratio : Jsont.json option;
+  fullsize : string;
+  thumb : string;
 }
 
-let image_jsont =
-  Jsont.Object.map ~kind:"Image"
-    (fun _typ image alt aspect_ratio -> { image; alt; aspect_ratio })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#image" ~enc:(fun _ -> "app.bsky.embed.images#image")
-  |> Jsont.Object.mem "image" Atp.Blob_ref.jsont ~enc:(fun r -> r.image)
+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 view_image = {
-  thumb : string;
-  fullsize : string;
+type image = {
   alt : string;
   aspect_ratio : Jsont.json option;
+  image : Atp.Blob_ref.t;
 }
 
-let view_image_jsont =
-  Jsont.Object.map ~kind:"View_image"
-    (fun _typ thumb fullsize alt aspect_ratio -> { thumb; fullsize; alt; aspect_ratio })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.images#viewImage" ~enc:(fun _ -> "app.bsky.embed.images#viewImage")
-  |> Jsont.Object.mem "thumb" Jsont.string ~enc:(fun r -> r.thumb)
-  |> Jsont.Object.mem "fullsize" Jsont.string ~enc:(fun r -> r.fullsize)
+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 main = {
+type view = {
   images : Jsont.json list;
 }
 
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
+let view_jsont =
+  Jsont.Object.map ~kind:"View"
     (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 "$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 view = {
+type main = {
   images : Jsont.json list;
 }
 
-let view_jsont =
-  Jsont.Object.map ~kind:"View"
+let main_jsont =
+  Jsont.Object.map ~kind:"Main"
     (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 "$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 caption = {
-  lang : string;
-  file : Atp.Blob_ref.t;
-}
-
-let caption_jsont =
-  Jsont.Object.map ~kind:"Caption"
-    (fun _typ lang file -> { lang; file })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.video#caption" ~enc:(fun _ -> "app.bsky.embed.video#caption")
-  |> Jsont.Object.mem "lang" Jsont.string ~enc:(fun r -> r.lang)
-  |> Jsont.Object.mem "file" Atp.Blob_ref.jsont ~enc:(fun r -> r.file)
-  |> Jsont.Object.finish
-
 type view = {
+  alt : string option;
+  aspect_ratio : Jsont.json option;
   cid : string;
   playlist : string;
   thumbnail : string option;
-  alt : string option;
-  aspect_ratio : Jsont.json option;
 }
 
 let view_jsont =
   Jsont.Object.map ~kind:"View"
-    (fun _typ cid playlist thumbnail alt aspect_ratio -> { cid; playlist; thumbnail; alt; aspect_ratio })
+    (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.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.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 = {
-  video : Atp.Blob_ref.t;
-  captions : Jsont.json list option;
   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 video captions alt aspect_ratio -> { video; captions; alt; aspect_ratio })
+    (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.mem "video" Atp.Blob_ref.jsont ~enc:(fun r -> r.video)
-  |> Jsont.Object.opt_mem "captions" (Jsont.list Jsont.json) ~enc:(fun r -> r.captions)
   |> 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 main = {
-  record : Jsont.json;
-  media : Jsont.json;
-}
-
-let main_jsont =
-  Jsont.Object.map ~kind:"Main"
-    (fun _typ record media -> { record; media })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.recordWithMedia" ~enc:(fun _ -> "app.bsky.embed.recordWithMedia")
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.mem "media" Jsont.json ~enc:(fun r -> r.media)
-  |> Jsont.Object.finish
-
 type view = {
-  record : Jsont.json;
   media : Jsont.json;
+  record : Jsont.json;
 }
 
 let view_jsont =
   Jsont.Object.map ~kind:"View"
-    (fun _typ record media -> { record; media })
+    (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.mem "media" Jsont.json ~enc:(fun r -> r.media)
   |> Jsont.Object.finish
 
-      end
-      module Record = struct
 type main = {
-  record : Com.Atproto.Repo.StrongRef.main;
+  media : Jsont.json;
+  record : Jsont.json;
 }
 
 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
-
-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")
+    (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 = {
-  uri : string;
+  author : Jsont.json;
   cid : string;
-  author : Jsont.json;
-  value : Jsont.json;
+  embeds : Jsont.json list option;
+  indexed_at : string;
   labels : Com.Atproto.Label.Defs.label list option;
-  reply_count : int option;
-  repost_count : int option;
   like_count : int option;
   quote_count : int option;
-  embeds : Jsont.json list option;
-  indexed_at : string;
+  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 uri cid author value labels reply_count repost_count like_count quote_count embeds indexed_at -> { uri; cid; author; value; labels; reply_count; repost_count; like_count; quote_count; embeds; indexed_at })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
-  |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
+  |> 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.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 "embeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.embeds)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> 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 = {
-  uri : string;
   not_found : bool;
+  uri : string;
 }
 
 let view_not_found_jsont =
   Jsont.Object.map ~kind:"View_not_found"
-    (fun _typ uri not_found -> { uri; 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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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_blocked = {
+type view_detached = {
+  detached : bool;
   uri : string;
-  blocked : bool;
+}
+
+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 uri blocked author -> { uri; blocked; author })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> 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 "author" Jsont.json ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-type view_detached = {
-  uri : string;
-  detached : bool;
+type view = {
+  record : Jsont.json;
 }
 
-let view_detached_jsont =
-  Jsont.Object.map ~kind:"View_detached"
-    (fun _typ uri detached -> { uri; detached })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.embed.record#viewDetached" ~enc:(fun _ -> "app.bsky.embed.record#viewDetached")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "detached" Jsont.bool ~enc:(fun r -> r.detached)
+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 RegisterPush = struct
 type input = {
+  age_restricted : bool option;
+  app_id : string;
+  platform : string;
   service_did : string;
   token : string;
-  platform : string;
-  app_id : string;
-  age_restricted : bool option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ service_did token platform app_id age_restricted -> { service_did; token; platform; app_id; age_restricted })
+    (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.mem "platform" Jsont.string ~enc:(fun r -> r.platform)
-  |> Jsont.Object.mem "appId" Jsont.string ~enc:(fun r -> r.app_id)
-  |> Jsont.Object.opt_mem "ageRestricted" Jsont.bool ~enc:(fun r -> r.age_restricted)
   |> Jsont.Object.finish
 
       end
       module ListNotifications = struct
 type notification = {
-  uri : string;
+  author : Jsont.json;
   cid : string;
-  author : Jsont.json;
+  indexed_at : string;
+  is_read : bool;
+  labels : Com.Atproto.Label.Defs.label list option;
   reason : string;
   reason_subject : string option;
   record : Jsont.json;
-  is_read : bool;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
+  uri : string;
 }
 
 let notification_jsont =
   Jsont.Object.map ~kind:"Notification"
-    (fun _typ uri cid author reason reason_subject record is_read indexed_at labels -> { uri; cid; author; reason; reason_subject; record; is_read; indexed_at; labels })
+    (fun _typ author cid indexed_at is_read labels reason reason_subject record uri -> { author; cid; indexed_at; is_read; labels; reason; reason_subject; record; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.listNotifications#notification" ~enc:(fun _ -> "app.bsky.notification.listNotifications#notification")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.mem "isRead" Jsont.bool ~enc:(fun r -> r.is_read)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
   |> Jsont.Object.mem "reason" Jsont.string ~enc:(fun r -> r.reason)
   |> Jsont.Object.opt_mem "reasonSubject" Jsont.string ~enc:(fun r -> r.reason_subject)
   |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.mem "isRead" Jsont.bool ~enc:(fun r -> r.is_read)
-  |> 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.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type params = {
-  reasons : string list option;
+  cursor : string option;
   limit : int option;
   priority : bool option;
-  cursor : string option;
+  reasons : string list option;
   seen_at : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun reasons limit priority cursor seen_at -> {
-      reasons;
+    (fun cursor limit priority reasons seen_at -> {
+      cursor;
       limit;
       priority;
-      cursor;
+      reasons;
       seen_at;
     })
-  |> Jsont.Object.opt_mem "reasons" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.reasons)
+  |> 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 "priority" Jsont.bool
        ~enc:(fun r -> r.priority)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "reasons" (Jsont.list Jsont.string)
+       ~enc:(fun r -> r.reasons)
   |> Jsont.Object.opt_mem "seenAt" Jsont.string
        ~enc:(fun r -> r.seen_at)
   |> Jsont.Object.finish
···
       end
       module UnregisterPush = struct
 type input = {
+  app_id : string;
+  platform : string;
   service_did : string;
   token : string;
-  platform : string;
-  app_id : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ service_did token platform app_id -> { service_did; token; platform; app_id })
+    (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)
-  |> Jsont.Object.mem "platform" Jsont.string ~enc:(fun r -> r.platform)
-  |> Jsont.Object.mem "appId" Jsont.string ~enc:(fun r -> r.app_id)
   |> Jsont.Object.finish
 
       end
···
 
 let record_deleted_jsont = Jsont.ignore
 
-type chat_preference = {
-  include_ : string;
+type preference = {
+  list_ : bool;
   push : bool;
 }
 
-let chat_preference_jsont =
-  Jsont.Object.map ~kind:"Chat_preference"
-    (fun _typ include_ push -> { include_; push })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#chatPreference" ~enc:(fun _ -> "app.bsky.notification.defs#chatPreference")
-  |> Jsont.Object.mem "include" Jsont.string ~enc:(fun r -> r.include_)
+let preference_jsont =
+  Jsont.Object.map ~kind:"Preference"
+    (fun _typ list_ push -> { list_; push })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#preference" ~enc:(fun _ -> "app.bsky.notification.defs#preference")
+  |> Jsont.Object.mem "list" Jsont.bool ~enc:(fun r -> r.list_)
   |> Jsont.Object.mem "push" Jsont.bool ~enc:(fun r -> r.push)
   |> Jsont.Object.finish
 
···
   |> Jsont.Object.mem "push" Jsont.bool ~enc:(fun r -> r.push)
   |> Jsont.Object.finish
 
-type preference = {
-  list_ : bool;
+type chat_preference = {
+  include_ : string;
   push : bool;
 }
 
-let preference_jsont =
-  Jsont.Object.map ~kind:"Preference"
-    (fun _typ list_ push -> { list_; push })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#preference" ~enc:(fun _ -> "app.bsky.notification.defs#preference")
-  |> Jsont.Object.mem "list" Jsont.bool ~enc:(fun r -> r.list_)
+let chat_preference_jsont =
+  Jsont.Object.map ~kind:"Chat_preference"
+    (fun _typ include_ push -> { include_; push })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#chatPreference" ~enc:(fun _ -> "app.bsky.notification.defs#chatPreference")
+  |> Jsont.Object.mem "include" Jsont.string ~enc:(fun r -> r.include_)
   |> Jsont.Object.mem "push" Jsont.bool ~enc:(fun r -> r.push)
   |> Jsont.Object.finish
 
···
   |> Jsont.Object.mem "reply" Jsont.bool ~enc:(fun r -> r.reply)
   |> Jsont.Object.finish
 
+type subject_activity_subscription = {
+  activity_subscription : Jsont.json;
+  subject : string;
+}
+
+let subject_activity_subscription_jsont =
+  Jsont.Object.map ~kind:"Subject_activity_subscription"
+    (fun _typ activity_subscription subject -> { activity_subscription; subject })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#subjectActivitySubscription" ~enc:(fun _ -> "app.bsky.notification.defs#subjectActivitySubscription")
+  |> Jsont.Object.mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
+  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.finish
+
 type preferences = {
   chat : Jsont.json;
   follow : Jsont.json;
···
   |> Jsont.Object.mem "verified" Jsont.json ~enc:(fun r -> r.verified)
   |> Jsont.Object.finish
 
-type subject_activity_subscription = {
-  subject : string;
-  activity_subscription : Jsont.json;
-}
-
-let subject_activity_subscription_jsont =
-  Jsont.Object.map ~kind:"Subject_activity_subscription"
-    (fun _typ subject activity_subscription -> { subject; activity_subscription })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.defs#subjectActivitySubscription" ~enc:(fun _ -> "app.bsky.notification.defs#subjectActivitySubscription")
-  |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
-  |> Jsont.Object.finish
-
       end
       module Declaration = struct
 type main = {
···
       end
       module ListActivitySubscriptions = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
+  |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module PutActivitySubscription = struct
 type input = {
-  subject : string;
   activity_subscription : Jsont.json;
+  subject : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ subject activity_subscription -> { subject; activity_subscription })
+    (fun _typ activity_subscription subject -> { activity_subscription; subject })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.putActivitySubscription#input" ~enc:(fun _ -> "app.bsky.notification.putActivitySubscription#input")
+  |> Jsont.Object.mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
   |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
   |> Jsont.Object.finish
 
 type output = {
-  subject : string;
   activity_subscription : Jsont.json option;
+  subject : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ subject activity_subscription -> { subject; activity_subscription })
+    (fun _typ activity_subscription subject -> { activity_subscription; subject })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.notification.putActivitySubscription#output" ~enc:(fun _ -> "app.bsky.notification.putActivitySubscription#output")
+  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
   |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
   |> Jsont.Object.finish
 
       end
···
 let live_jsont = Jsont.string
 
 type main = {
-  status : string;
-  embed : Jsont.json option;
+  created_at : string;
   duration_minutes : int option;
-  created_at : string;
+  embed : Jsont.json option;
+  status : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ status embed duration_minutes created_at -> { status; embed; duration_minutes; created_at })
+    (fun _typ created_at duration_minutes embed status -> { created_at; duration_minutes; embed; status })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.status" ~enc:(fun _ -> "app.bsky.actor.status")
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
-  |> Jsont.Object.opt_mem "durationMinutes" Jsont.int ~enc:(fun r -> r.duration_minutes)
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> 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 = {
-  display_name : string option;
-  description : string option;
-  pronouns : string option;
-  website : string option;
   avatar : Atp.Blob_ref.t option;
   banner : Atp.Blob_ref.t option;
-  labels : Com.Atproto.Label.Defs.self_labels 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;
-  created_at : string option;
+  pronouns : string option;
+  website : string option;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ display_name description pronouns website avatar banner labels joined_via_starter_pack pinned_post created_at -> { display_name; description; pronouns; website; avatar; banner; labels; joined_via_starter_pack; pinned_post; created_at })
+    (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 "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> 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.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 "joinedViaStarterPack" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.joined_via_starter_pack)
   |> Jsont.Object.opt_mem "pinnedPost" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.pinned_post)
-  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> 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 Defs = struct
-type profile_associated_chat = {
-  allow_incoming : string;
-}
-
-let profile_associated_chat_jsont =
-  Jsont.Object.map ~kind:"Profile_associated_chat"
-    (fun _typ allow_incoming -> { allow_incoming })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociatedChat" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociatedChat")
-  |> Jsont.Object.mem "allowIncoming" Jsont.string ~enc:(fun r -> r.allow_incoming)
-  |> Jsont.Object.finish
-
-type profile_associated_activity_subscription = {
-  allow_subscriptions : string;
-}
-
-let profile_associated_activity_subscription_jsont =
-  Jsont.Object.map ~kind:"Profile_associated_activity_subscription"
-    (fun _typ allow_subscriptions -> { allow_subscriptions })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociatedActivitySubscription" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociatedActivitySubscription")
-  |> Jsont.Object.mem "allowSubscriptions" Jsont.string ~enc:(fun r -> r.allow_subscriptions)
-  |> Jsont.Object.finish
-
 type verification_view = {
+  created_at : string;
+  is_valid : bool;
   issuer : string;
   uri : string;
-  is_valid : bool;
-  created_at : string;
 }
 
 let verification_view_jsont =
   Jsont.Object.map ~kind:"Verification_view"
-    (fun _typ issuer uri is_valid created_at -> { issuer; uri; is_valid; created_at })
+    (fun _typ created_at is_valid issuer uri -> { created_at; is_valid; issuer; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#verificationView" ~enc:(fun _ -> "app.bsky.actor.defs#verificationView")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "isValid" Jsont.bool ~enc:(fun r -> r.is_valid)
   |> Jsont.Object.mem "issuer" Jsont.string ~enc:(fun r -> r.issuer)
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "isValid" Jsont.bool ~enc:(fun r -> r.is_valid)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
-type preferences = Jsont.json list
-let preferences_jsont = (Jsont.list Jsont.json)
+type verification_prefs = {
+  hide_badges : bool option;
+}
+
+let verification_prefs_jsont =
+  Jsont.Object.map ~kind:"Verification_prefs"
+    (fun _typ hide_badges -> { hide_badges })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#verificationPrefs" ~enc:(fun _ -> "app.bsky.actor.defs#verificationPrefs")
+  |> Jsont.Object.opt_mem "hideBadges" Jsont.bool ~enc:(fun r -> r.hide_badges)
+  |> Jsont.Object.finish
+
+type thread_view_pref = {
+  sort : string option;
+}
+
+let thread_view_pref_jsont =
+  Jsont.Object.map ~kind:"Thread_view_pref"
+    (fun _typ sort -> { sort })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#threadViewPref" ~enc:(fun _ -> "app.bsky.actor.defs#threadViewPref")
+  |> Jsont.Object.opt_mem "sort" Jsont.string ~enc:(fun r -> r.sort)
+  |> Jsont.Object.finish
 
-type adult_content_pref = {
-  enabled : bool;
+type status_view = {
+  cid : string option;
+  embed : Jsont.json option;
+  expires_at : string option;
+  is_active : bool option;
+  is_disabled : bool option;
+  record : Jsont.json;
+  status : string;
+  uri : string option;
 }
 
-let adult_content_pref_jsont =
-  Jsont.Object.map ~kind:"Adult_content_pref"
-    (fun _typ enabled -> { enabled })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#adultContentPref" ~enc:(fun _ -> "app.bsky.actor.defs#adultContentPref")
-  |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
+let status_view_jsont =
+  Jsont.Object.map ~kind:"Status_view"
+    (fun _typ cid embed expires_at is_active is_disabled record status uri -> { cid; embed; expires_at; is_active; is_disabled; record; status; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#statusView" ~enc:(fun _ -> "app.bsky.actor.defs#statusView")
+  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
+  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
+  |> Jsont.Object.opt_mem "isActive" Jsont.bool ~enc:(fun r -> r.is_active)
+  |> Jsont.Object.opt_mem "isDisabled" Jsont.bool ~enc:(fun r -> r.is_disabled)
+  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
-type content_label_pref = {
-  labeler_did : string option;
-  label : string;
-  visibility : string;
+type saved_feeds_pref = {
+  pinned : string list;
+  saved : string list;
+  timeline_index : int option;
 }
 
-let content_label_pref_jsont =
-  Jsont.Object.map ~kind:"Content_label_pref"
-    (fun _typ labeler_did label visibility -> { labeler_did; label; visibility })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#contentLabelPref" ~enc:(fun _ -> "app.bsky.actor.defs#contentLabelPref")
-  |> Jsont.Object.opt_mem "labelerDid" Jsont.string ~enc:(fun r -> r.labeler_did)
-  |> Jsont.Object.mem "label" Jsont.string ~enc:(fun r -> r.label)
-  |> Jsont.Object.mem "visibility" Jsont.string ~enc:(fun r -> r.visibility)
+let saved_feeds_pref_jsont =
+  Jsont.Object.map ~kind:"Saved_feeds_pref"
+    (fun _typ pinned saved timeline_index -> { pinned; saved; timeline_index })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#savedFeedsPref" ~enc:(fun _ -> "app.bsky.actor.defs#savedFeedsPref")
+  |> Jsont.Object.mem "pinned" (Jsont.list Jsont.string) ~enc:(fun r -> r.pinned)
+  |> Jsont.Object.mem "saved" (Jsont.list Jsont.string) ~enc:(fun r -> r.saved)
+  |> Jsont.Object.opt_mem "timelineIndex" Jsont.int ~enc:(fun r -> r.timeline_index)
   |> Jsont.Object.finish
 
 type saved_feed = {
   id : string;
+  pinned : bool;
   type_ : string;
   value : string;
-  pinned : bool;
 }
 
 let saved_feed_jsont =
   Jsont.Object.map ~kind:"Saved_feed"
-    (fun _typ id type_ value pinned -> { id; type_; value; pinned })
+    (fun _typ id pinned type_ value -> { id; pinned; type_; value })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#savedFeed" ~enc:(fun _ -> "app.bsky.actor.defs#savedFeed")
   |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
+  |> Jsont.Object.mem "pinned" Jsont.bool ~enc:(fun r -> r.pinned)
   |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.type_)
   |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
-  |> Jsont.Object.mem "pinned" Jsont.bool ~enc:(fun r -> r.pinned)
   |> Jsont.Object.finish
 
-type saved_feeds_pref = {
-  pinned : string list;
-  saved : string list;
-  timeline_index : int option;
+type profile_associated_chat = {
+  allow_incoming : string;
 }
 
-let saved_feeds_pref_jsont =
-  Jsont.Object.map ~kind:"Saved_feeds_pref"
-    (fun _typ pinned saved timeline_index -> { pinned; saved; timeline_index })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#savedFeedsPref" ~enc:(fun _ -> "app.bsky.actor.defs#savedFeedsPref")
-  |> Jsont.Object.mem "pinned" (Jsont.list Jsont.string) ~enc:(fun r -> r.pinned)
-  |> Jsont.Object.mem "saved" (Jsont.list Jsont.string) ~enc:(fun r -> r.saved)
-  |> Jsont.Object.opt_mem "timelineIndex" Jsont.int ~enc:(fun r -> r.timeline_index)
+let profile_associated_chat_jsont =
+  Jsont.Object.map ~kind:"Profile_associated_chat"
+    (fun _typ allow_incoming -> { allow_incoming })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociatedChat" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociatedChat")
+  |> Jsont.Object.mem "allowIncoming" Jsont.string ~enc:(fun r -> r.allow_incoming)
+  |> Jsont.Object.finish
+
+type profile_associated_activity_subscription = {
+  allow_subscriptions : string;
+}
+
+let profile_associated_activity_subscription_jsont =
+  Jsont.Object.map ~kind:"Profile_associated_activity_subscription"
+    (fun _typ allow_subscriptions -> { allow_subscriptions })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociatedActivitySubscription" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociatedActivitySubscription")
+  |> Jsont.Object.mem "allowSubscriptions" Jsont.string ~enc:(fun r -> r.allow_subscriptions)
+  |> Jsont.Object.finish
+
+type preferences = Jsont.json list
+let preferences_jsont = (Jsont.list Jsont.json)
+
+type post_interaction_settings_pref = {
+  postgate_embedding_rules : Jsont.json list option;
+  threadgate_allow_rules : Jsont.json list option;
+}
+
+let post_interaction_settings_pref_jsont =
+  Jsont.Object.map ~kind:"Post_interaction_settings_pref"
+    (fun _typ postgate_embedding_rules threadgate_allow_rules -> { postgate_embedding_rules; threadgate_allow_rules })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#postInteractionSettingsPref" ~enc:(fun _ -> "app.bsky.actor.defs#postInteractionSettingsPref")
+  |> Jsont.Object.opt_mem "postgateEmbeddingRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.postgate_embedding_rules)
+  |> Jsont.Object.opt_mem "threadgateAllowRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.threadgate_allow_rules)
   |> Jsont.Object.finish
 
 type personal_details_pref = {
···
   |> Jsont.Object.opt_mem "birthDate" Jsont.string ~enc:(fun r -> r.birth_date)
   |> Jsont.Object.finish
 
-type declared_age_pref = {
-  is_over_age13 : bool option;
-  is_over_age16 : bool option;
-  is_over_age18 : bool option;
+type nux = {
+  completed : bool;
+  data : string option;
+  expires_at : string option;
+  id : string;
 }
 
-let declared_age_pref_jsont =
-  Jsont.Object.map ~kind:"Declared_age_pref"
-    (fun _typ is_over_age13 is_over_age16 is_over_age18 -> { is_over_age13; is_over_age16; is_over_age18 })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#declaredAgePref" ~enc:(fun _ -> "app.bsky.actor.defs#declaredAgePref")
-  |> Jsont.Object.opt_mem "isOverAge13" Jsont.bool ~enc:(fun r -> r.is_over_age13)
-  |> Jsont.Object.opt_mem "isOverAge16" Jsont.bool ~enc:(fun r -> r.is_over_age16)
-  |> Jsont.Object.opt_mem "isOverAge18" Jsont.bool ~enc:(fun r -> r.is_over_age18)
+let nux_jsont =
+  Jsont.Object.map ~kind:"Nux"
+    (fun _typ completed data expires_at id -> { completed; data; expires_at; id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#nux" ~enc:(fun _ -> "app.bsky.actor.defs#nux")
+  |> Jsont.Object.mem "completed" Jsont.bool ~enc:(fun r -> r.completed)
+  |> Jsont.Object.opt_mem "data" Jsont.string ~enc:(fun r -> r.data)
+  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
+  |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
   |> Jsont.Object.finish
 
-type feed_view_pref = {
-  feed : string;
-  hide_replies : bool option;
-  hide_replies_by_unfollowed : bool option;
-  hide_replies_by_like_count : int option;
-  hide_reposts : bool option;
-  hide_quote_posts : bool option;
-}
+type muted_word_target = string
+let muted_word_target_jsont = Jsont.string
 
-let feed_view_pref_jsont =
-  Jsont.Object.map ~kind:"Feed_view_pref"
-    (fun _typ feed hide_replies hide_replies_by_unfollowed hide_replies_by_like_count hide_reposts hide_quote_posts -> { feed; hide_replies; hide_replies_by_unfollowed; hide_replies_by_like_count; hide_reposts; hide_quote_posts })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#feedViewPref" ~enc:(fun _ -> "app.bsky.actor.defs#feedViewPref")
-  |> Jsont.Object.mem "feed" Jsont.string ~enc:(fun r -> r.feed)
-  |> Jsont.Object.opt_mem "hideReplies" Jsont.bool ~enc:(fun r -> r.hide_replies)
-  |> Jsont.Object.opt_mem "hideRepliesByUnfollowed" Jsont.bool ~enc:(fun r -> r.hide_replies_by_unfollowed)
-  |> Jsont.Object.opt_mem "hideRepliesByLikeCount" Jsont.int ~enc:(fun r -> r.hide_replies_by_like_count)
-  |> Jsont.Object.opt_mem "hideReposts" Jsont.bool ~enc:(fun r -> r.hide_reposts)
-  |> Jsont.Object.opt_mem "hideQuotePosts" Jsont.bool ~enc:(fun r -> r.hide_quote_posts)
-  |> Jsont.Object.finish
-
-type thread_view_pref = {
-  sort : string option;
+type labeler_pref_item = {
+  did : string;
 }
 
-let thread_view_pref_jsont =
-  Jsont.Object.map ~kind:"Thread_view_pref"
-    (fun _typ sort -> { sort })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#threadViewPref" ~enc:(fun _ -> "app.bsky.actor.defs#threadViewPref")
-  |> Jsont.Object.opt_mem "sort" Jsont.string ~enc:(fun r -> r.sort)
+let labeler_pref_item_jsont =
+  Jsont.Object.map ~kind:"Labeler_pref_item"
+    (fun _typ did -> { did })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#labelerPrefItem" ~enc:(fun _ -> "app.bsky.actor.defs#labelerPrefItem")
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
   |> Jsont.Object.finish
 
 type interests_pref = {
···
   |> Jsont.Object.mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
   |> Jsont.Object.finish
 
-type muted_word_target = string
-let muted_word_target_jsont = Jsont.string
-
 type hidden_posts_pref = {
   items : string list;
 }
···
   |> Jsont.Object.mem "items" (Jsont.list Jsont.string) ~enc:(fun r -> r.items)
   |> Jsont.Object.finish
 
-type labeler_pref_item = {
-  did : string;
-}
-
-let labeler_pref_item_jsont =
-  Jsont.Object.map ~kind:"Labeler_pref_item"
-    (fun _typ did -> { did })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#labelerPrefItem" ~enc:(fun _ -> "app.bsky.actor.defs#labelerPrefItem")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.finish
-
-type bsky_app_progress_guide = {
-  guide : string;
-}
-
-let bsky_app_progress_guide_jsont =
-  Jsont.Object.map ~kind:"Bsky_app_progress_guide"
-    (fun _typ guide -> { guide })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#bskyAppProgressGuide" ~enc:(fun _ -> "app.bsky.actor.defs#bskyAppProgressGuide")
-  |> Jsont.Object.mem "guide" Jsont.string ~enc:(fun r -> r.guide)
-  |> Jsont.Object.finish
-
-type nux = {
-  id : string;
-  completed : bool;
-  data : string option;
-  expires_at : string option;
+type feed_view_pref = {
+  feed : string;
+  hide_quote_posts : bool option;
+  hide_replies : bool option;
+  hide_replies_by_like_count : int option;
+  hide_replies_by_unfollowed : bool option;
+  hide_reposts : bool option;
 }
 
-let nux_jsont =
-  Jsont.Object.map ~kind:"Nux"
-    (fun _typ id completed data expires_at -> { id; completed; data; expires_at })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#nux" ~enc:(fun _ -> "app.bsky.actor.defs#nux")
-  |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
-  |> Jsont.Object.mem "completed" Jsont.bool ~enc:(fun r -> r.completed)
-  |> Jsont.Object.opt_mem "data" Jsont.string ~enc:(fun r -> r.data)
-  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
+let feed_view_pref_jsont =
+  Jsont.Object.map ~kind:"Feed_view_pref"
+    (fun _typ feed hide_quote_posts hide_replies hide_replies_by_like_count hide_replies_by_unfollowed hide_reposts -> { feed; hide_quote_posts; hide_replies; hide_replies_by_like_count; hide_replies_by_unfollowed; hide_reposts })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#feedViewPref" ~enc:(fun _ -> "app.bsky.actor.defs#feedViewPref")
+  |> Jsont.Object.mem "feed" Jsont.string ~enc:(fun r -> r.feed)
+  |> Jsont.Object.opt_mem "hideQuotePosts" Jsont.bool ~enc:(fun r -> r.hide_quote_posts)
+  |> Jsont.Object.opt_mem "hideReplies" Jsont.bool ~enc:(fun r -> r.hide_replies)
+  |> Jsont.Object.opt_mem "hideRepliesByLikeCount" Jsont.int ~enc:(fun r -> r.hide_replies_by_like_count)
+  |> Jsont.Object.opt_mem "hideRepliesByUnfollowed" Jsont.bool ~enc:(fun r -> r.hide_replies_by_unfollowed)
+  |> Jsont.Object.opt_mem "hideReposts" Jsont.bool ~enc:(fun r -> r.hide_reposts)
   |> Jsont.Object.finish
 
-type verification_prefs = {
-  hide_badges : bool option;
+type declared_age_pref = {
+  is_over_age13 : bool option;
+  is_over_age16 : bool option;
+  is_over_age18 : bool option;
 }
 
-let verification_prefs_jsont =
-  Jsont.Object.map ~kind:"Verification_prefs"
-    (fun _typ hide_badges -> { hide_badges })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#verificationPrefs" ~enc:(fun _ -> "app.bsky.actor.defs#verificationPrefs")
-  |> Jsont.Object.opt_mem "hideBadges" Jsont.bool ~enc:(fun r -> r.hide_badges)
+let declared_age_pref_jsont =
+  Jsont.Object.map ~kind:"Declared_age_pref"
+    (fun _typ is_over_age13 is_over_age16 is_over_age18 -> { is_over_age13; is_over_age16; is_over_age18 })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#declaredAgePref" ~enc:(fun _ -> "app.bsky.actor.defs#declaredAgePref")
+  |> Jsont.Object.opt_mem "isOverAge13" Jsont.bool ~enc:(fun r -> r.is_over_age13)
+  |> Jsont.Object.opt_mem "isOverAge16" Jsont.bool ~enc:(fun r -> r.is_over_age16)
+  |> Jsont.Object.opt_mem "isOverAge18" Jsont.bool ~enc:(fun r -> r.is_over_age18)
   |> Jsont.Object.finish
 
-type post_interaction_settings_pref = {
-  threadgate_allow_rules : Jsont.json list option;
-  postgate_embedding_rules : Jsont.json list option;
+type content_label_pref = {
+  label : string;
+  labeler_did : string option;
+  visibility : string;
 }
 
-let post_interaction_settings_pref_jsont =
-  Jsont.Object.map ~kind:"Post_interaction_settings_pref"
-    (fun _typ threadgate_allow_rules postgate_embedding_rules -> { threadgate_allow_rules; postgate_embedding_rules })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#postInteractionSettingsPref" ~enc:(fun _ -> "app.bsky.actor.defs#postInteractionSettingsPref")
-  |> Jsont.Object.opt_mem "threadgateAllowRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.threadgate_allow_rules)
-  |> Jsont.Object.opt_mem "postgateEmbeddingRules" (Jsont.list Jsont.json) ~enc:(fun r -> r.postgate_embedding_rules)
+let content_label_pref_jsont =
+  Jsont.Object.map ~kind:"Content_label_pref"
+    (fun _typ label labeler_did visibility -> { label; labeler_did; visibility })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#contentLabelPref" ~enc:(fun _ -> "app.bsky.actor.defs#contentLabelPref")
+  |> Jsont.Object.mem "label" Jsont.string ~enc:(fun r -> r.label)
+  |> Jsont.Object.opt_mem "labelerDid" Jsont.string ~enc:(fun r -> r.labeler_did)
+  |> Jsont.Object.mem "visibility" Jsont.string ~enc:(fun r -> r.visibility)
   |> Jsont.Object.finish
 
-type status_view = {
-  uri : string option;
-  cid : string option;
-  status : string;
-  record : Jsont.json;
-  embed : Jsont.json option;
-  expires_at : string option;
-  is_active : bool option;
-  is_disabled : bool option;
+type bsky_app_progress_guide = {
+  guide : string;
 }
 
-let status_view_jsont =
-  Jsont.Object.map ~kind:"Status_view"
-    (fun _typ uri cid status record embed expires_at is_active is_disabled -> { uri; cid; status; record; embed; expires_at; is_active; is_disabled })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#statusView" ~enc:(fun _ -> "app.bsky.actor.defs#statusView")
-  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
-  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
-  |> Jsont.Object.opt_mem "isActive" Jsont.bool ~enc:(fun r -> r.is_active)
-  |> Jsont.Object.opt_mem "isDisabled" Jsont.bool ~enc:(fun r -> r.is_disabled)
+let bsky_app_progress_guide_jsont =
+  Jsont.Object.map ~kind:"Bsky_app_progress_guide"
+    (fun _typ guide -> { guide })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#bskyAppProgressGuide" ~enc:(fun _ -> "app.bsky.actor.defs#bskyAppProgressGuide")
+  |> Jsont.Object.mem "guide" Jsont.string ~enc:(fun r -> r.guide)
   |> Jsont.Object.finish
 
-type profile_associated = {
-  lists : int option;
-  feedgens : int option;
-  starter_packs : int option;
-  labeler : bool option;
-  chat : Jsont.json option;
-  activity_subscription : Jsont.json option;
+type adult_content_pref = {
+  enabled : bool;
 }
 
-let profile_associated_jsont =
-  Jsont.Object.map ~kind:"Profile_associated"
-    (fun _typ lists feedgens starter_packs labeler chat activity_subscription -> { lists; feedgens; starter_packs; labeler; chat; activity_subscription })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociated" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociated")
-  |> Jsont.Object.opt_mem "lists" Jsont.int ~enc:(fun r -> r.lists)
-  |> Jsont.Object.opt_mem "feedgens" Jsont.int ~enc:(fun r -> r.feedgens)
-  |> Jsont.Object.opt_mem "starterPacks" Jsont.int ~enc:(fun r -> r.starter_packs)
-  |> Jsont.Object.opt_mem "labeler" Jsont.bool ~enc:(fun r -> r.labeler)
-  |> Jsont.Object.opt_mem "chat" Jsont.json ~enc:(fun r -> r.chat)
-  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
+let adult_content_pref_jsont =
+  Jsont.Object.map ~kind:"Adult_content_pref"
+    (fun _typ enabled -> { enabled })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#adultContentPref" ~enc:(fun _ -> "app.bsky.actor.defs#adultContentPref")
+  |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
   |> Jsont.Object.finish
 
 type verification_state = {
+  trusted_verifier_status : string;
   verifications : Jsont.json list;
   verified_status : string;
-  trusted_verifier_status : string;
 }
 
 let verification_state_jsont =
   Jsont.Object.map ~kind:"Verification_state"
-    (fun _typ verifications verified_status trusted_verifier_status -> { verifications; verified_status; trusted_verifier_status })
+    (fun _typ trusted_verifier_status verifications verified_status -> { trusted_verifier_status; verifications; verified_status })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#verificationState" ~enc:(fun _ -> "app.bsky.actor.defs#verificationState")
+  |> Jsont.Object.mem "trustedVerifierStatus" Jsont.string ~enc:(fun r -> r.trusted_verifier_status)
   |> Jsont.Object.mem "verifications" (Jsont.list Jsont.json) ~enc:(fun r -> r.verifications)
   |> Jsont.Object.mem "verifiedStatus" Jsont.string ~enc:(fun r -> r.verified_status)
-  |> Jsont.Object.mem "trustedVerifierStatus" Jsont.string ~enc:(fun r -> r.trusted_verifier_status)
   |> Jsont.Object.finish
 
 type saved_feeds_pref_v2 = {
···
   |> Jsont.Object.mem "items" (Jsont.list Jsont.json) ~enc:(fun r -> r.items)
   |> Jsont.Object.finish
 
+type profile_associated = {
+  activity_subscription : Jsont.json option;
+  chat : Jsont.json option;
+  feedgens : int option;
+  labeler : bool option;
+  lists : int option;
+  starter_packs : int option;
+}
+
+let profile_associated_jsont =
+  Jsont.Object.map ~kind:"Profile_associated"
+    (fun _typ activity_subscription chat feedgens labeler lists starter_packs -> { activity_subscription; chat; feedgens; labeler; lists; starter_packs })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileAssociated" ~enc:(fun _ -> "app.bsky.actor.defs#profileAssociated")
+  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
+  |> Jsont.Object.opt_mem "chat" Jsont.json ~enc:(fun r -> r.chat)
+  |> Jsont.Object.opt_mem "feedgens" Jsont.int ~enc:(fun r -> r.feedgens)
+  |> Jsont.Object.opt_mem "labeler" Jsont.bool ~enc:(fun r -> r.labeler)
+  |> Jsont.Object.opt_mem "lists" Jsont.int ~enc:(fun r -> r.lists)
+  |> Jsont.Object.opt_mem "starterPacks" Jsont.int ~enc:(fun r -> r.starter_packs)
+  |> Jsont.Object.finish
+
 type muted_word = {
+  actor_target : string option;
+  expires_at : string option;
   id : string option;
-  value : string;
   targets : Jsont.json list;
-  actor_target : string option;
-  expires_at : string option;
+  value : string;
 }
 
 let muted_word_jsont =
   Jsont.Object.map ~kind:"Muted_word"
-    (fun _typ id value targets actor_target expires_at -> { id; value; targets; actor_target; expires_at })
+    (fun _typ actor_target expires_at id targets value -> { actor_target; expires_at; id; targets; value })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#mutedWord" ~enc:(fun _ -> "app.bsky.actor.defs#mutedWord")
+  |> Jsont.Object.opt_mem "actorTarget" Jsont.string ~enc:(fun r -> r.actor_target)
+  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
   |> Jsont.Object.opt_mem "id" Jsont.string ~enc:(fun r -> r.id)
+  |> Jsont.Object.mem "targets" (Jsont.list Jsont.json) ~enc:(fun r -> r.targets)
   |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
-  |> Jsont.Object.mem "targets" (Jsont.list Jsont.json) ~enc:(fun r -> r.targets)
-  |> Jsont.Object.opt_mem "actorTarget" Jsont.string ~enc:(fun r -> r.actor_target)
-  |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
   |> Jsont.Object.finish
 
 type labelers_pref = {
···
 
 type bsky_app_state_pref = {
   active_progress_guide : Jsont.json option;
-  queued_nudges : string list option;
   nuxs : Jsont.json list option;
+  queued_nudges : string list option;
 }
 
 let bsky_app_state_pref_jsont =
   Jsont.Object.map ~kind:"Bsky_app_state_pref"
-    (fun _typ active_progress_guide queued_nudges nuxs -> { active_progress_guide; queued_nudges; nuxs })
+    (fun _typ active_progress_guide nuxs queued_nudges -> { active_progress_guide; nuxs; queued_nudges })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#bskyAppStatePref" ~enc:(fun _ -> "app.bsky.actor.defs#bskyAppStatePref")
   |> Jsont.Object.opt_mem "activeProgressGuide" Jsont.json ~enc:(fun r -> r.active_progress_guide)
+  |> Jsont.Object.opt_mem "nuxs" (Jsont.list Jsont.json) ~enc:(fun r -> r.nuxs)
   |> Jsont.Object.opt_mem "queuedNudges" (Jsont.list Jsont.string) ~enc:(fun r -> r.queued_nudges)
-  |> Jsont.Object.opt_mem "nuxs" (Jsont.list Jsont.json) ~enc:(fun r -> r.nuxs)
   |> Jsont.Object.finish
 
 type muted_words_pref = {
···
   |> Jsont.Object.mem "items" (Jsont.list Jsont.json) ~enc:(fun r -> r.items)
   |> Jsont.Object.finish
 
-type profile_view_basic = {
+type viewer_state = {
+  activity_subscription : Jsont.json option;
+  blocked_by : bool option;
+  blocking : string option;
+  blocking_by_list : Jsont.json option;
+  followed_by : string option;
+  following : string option;
+  known_followers : Jsont.json option;
+  muted : bool option;
+  muted_by_list : Jsont.json option;
+}
+
+let viewer_state_jsont =
+  Jsont.Object.map ~kind:"Viewer_state"
+    (fun _typ activity_subscription blocked_by blocking blocking_by_list followed_by following known_followers muted muted_by_list -> { activity_subscription; blocked_by; blocking; blocking_by_list; followed_by; following; known_followers; muted; muted_by_list })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#viewerState" ~enc:(fun _ -> "app.bsky.actor.defs#viewerState")
+  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
+  |> Jsont.Object.opt_mem "blockedBy" Jsont.bool ~enc:(fun r -> r.blocked_by)
+  |> Jsont.Object.opt_mem "blocking" Jsont.string ~enc:(fun r -> r.blocking)
+  |> Jsont.Object.opt_mem "blockingByList" Jsont.json ~enc:(fun r -> r.blocking_by_list)
+  |> 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.opt_mem "knownFollowers" Jsont.json ~enc:(fun r -> r.known_followers)
+  |> Jsont.Object.opt_mem "muted" Jsont.bool ~enc:(fun r -> r.muted)
+  |> Jsont.Object.opt_mem "mutedByList" Jsont.json ~enc:(fun r -> r.muted_by_list)
+  |> Jsont.Object.finish
+
+type profile_view_detailed = {
+  associated : Jsont.json option;
+  avatar : string option;
+  banner : string option;
+  created_at : string option;
+  debug : Jsont.json option;
+  description : string option;
   did : string;
+  display_name : string option;
+  followers_count : int option;
+  follows_count : int option;
   handle : string;
-  display_name : string option;
+  indexed_at : string option;
+  joined_via_starter_pack : Jsont.json option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  pinned_post : Com.Atproto.Repo.StrongRef.main option;
+  posts_count : int option;
   pronouns : string option;
+  status : Jsont.json option;
+  verification : Jsont.json option;
+  viewer : Jsont.json option;
+  website : string option;
+}
+
+let profile_view_detailed_jsont =
+  Jsont.Object.map ~kind:"Profile_view_detailed"
+    (fun _typ associated avatar banner created_at debug description did display_name followers_count follows_count handle indexed_at joined_via_starter_pack labels pinned_post posts_count pronouns status verification viewer website -> { associated; avatar; banner; created_at; debug; description; did; display_name; followers_count; follows_count; handle; indexed_at; joined_via_starter_pack; labels; pinned_post; posts_count; pronouns; status; verification; viewer; website })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileViewDetailed" ~enc:(fun _ -> "app.bsky.actor.defs#profileViewDetailed")
+  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
+  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.opt_mem "banner" Jsont.string ~enc:(fun r -> r.banner)
+  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+  |> Jsont.Object.opt_mem "followersCount" Jsont.int ~enc:(fun r -> r.followers_count)
+  |> Jsont.Object.opt_mem "followsCount" Jsont.int ~enc:(fun r -> r.follows_count)
+  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
+  |> Jsont.Object.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "joinedViaStarterPack" Jsont.json ~enc:(fun r -> r.joined_via_starter_pack)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_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 "postsCount" Jsont.int ~enc:(fun r -> r.posts_count)
+  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
+  |> Jsont.Object.opt_mem "status" Jsont.json ~enc:(fun r -> r.status)
+  |> Jsont.Object.opt_mem "verification" Jsont.json ~enc:(fun r -> r.verification)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
+  |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
+  |> Jsont.Object.finish
+
+type profile_view_basic = {
+  associated : Jsont.json option;
   avatar : string option;
-  associated : Jsont.json option;
-  viewer : Jsont.json option;
+  created_at : string option;
+  debug : Jsont.json option;
+  did : string;
+  display_name : string option;
+  handle : string;
   labels : Com.Atproto.Label.Defs.label list option;
-  created_at : string option;
+  pronouns : string option;
+  status : Jsont.json option;
   verification : Jsont.json option;
-  status : Jsont.json option;
-  debug : Jsont.json option;
+  viewer : Jsont.json option;
 }
 
 let profile_view_basic_jsont =
   Jsont.Object.map ~kind:"Profile_view_basic"
-    (fun _typ did handle display_name pronouns avatar associated viewer labels created_at verification status debug -> { did; handle; display_name; pronouns; avatar; associated; viewer; labels; created_at; verification; status; debug })
+    (fun _typ associated avatar created_at debug did display_name handle labels pronouns status verification viewer -> { associated; avatar; created_at; debug; did; display_name; handle; labels; pronouns; status; verification; viewer })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileViewBasic" ~enc:(fun _ -> "app.bsky.actor.defs#profileViewBasic")
+  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
+  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
+  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
   |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
   |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
-  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
-  |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "verification" Jsont.json ~enc:(fun r -> r.verification)
+  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
   |> Jsont.Object.opt_mem "status" Jsont.json ~enc:(fun r -> r.status)
-  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
+  |> Jsont.Object.opt_mem "verification" Jsont.json ~enc:(fun r -> r.verification)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type profile_view = {
+  associated : Jsont.json option;
+  avatar : string option;
+  created_at : string option;
+  debug : Jsont.json option;
+  description : string option;
   did : string;
-  handle : string;
   display_name : string option;
-  pronouns : string option;
-  description : string option;
-  avatar : string option;
-  associated : Jsont.json option;
+  handle : string;
   indexed_at : string option;
-  created_at : string option;
-  viewer : Jsont.json option;
   labels : Com.Atproto.Label.Defs.label list option;
+  pronouns : string option;
+  status : Jsont.json option;
   verification : Jsont.json option;
-  status : Jsont.json option;
-  debug : Jsont.json option;
+  viewer : Jsont.json option;
 }
 
 let profile_view_jsont =
   Jsont.Object.map ~kind:"Profile_view"
-    (fun _typ did handle display_name pronouns description avatar associated indexed_at created_at viewer labels verification status debug -> { did; handle; display_name; pronouns; description; avatar; associated; indexed_at; created_at; viewer; labels; verification; status; debug })
+    (fun _typ associated avatar created_at debug description did display_name handle indexed_at labels pronouns status verification viewer -> { associated; avatar; created_at; debug; description; did; display_name; handle; indexed_at; labels; pronouns; status; verification; viewer })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileView" ~enc:(fun _ -> "app.bsky.actor.defs#profileView")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
-  |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "pronouns" Jsont.string ~enc:(fun r -> r.pronouns)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
   |> Jsont.Object.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
-  |> Jsont.Object.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.opt_mem "verification" Jsont.json ~enc:(fun r -> r.verification)
-  |> Jsont.Object.opt_mem "status" Jsont.json ~enc:(fun r -> r.status)
   |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
-  |> Jsont.Object.finish
-
-type profile_view_detailed = {
-  did : string;
-  handle : string;
-  display_name : string option;
-  description : string option;
-  pronouns : string option;
-  website : string option;
-  avatar : string option;
-  banner : string option;
-  followers_count : int option;
-  follows_count : int option;
-  posts_count : int option;
-  associated : Jsont.json option;
-  joined_via_starter_pack : Jsont.json option;
-  indexed_at : string option;
-  created_at : string option;
-  viewer : Jsont.json option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  pinned_post : Com.Atproto.Repo.StrongRef.main option;
-  verification : Jsont.json option;
-  status : Jsont.json option;
-  debug : Jsont.json option;
-}
-
-let profile_view_detailed_jsont =
-  Jsont.Object.map ~kind:"Profile_view_detailed"
-    (fun _typ did handle display_name description pronouns website avatar banner followers_count follows_count posts_count associated joined_via_starter_pack indexed_at created_at viewer labels pinned_post verification status debug -> { did; handle; display_name; description; pronouns; website; avatar; banner; followers_count; follows_count; posts_count; associated; joined_via_starter_pack; indexed_at; created_at; viewer; labels; pinned_post; verification; status; debug })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#profileViewDetailed" ~enc:(fun _ -> "app.bsky.actor.defs#profileViewDetailed")
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
   |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
   |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> 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.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "banner" Jsont.string ~enc:(fun r -> r.banner)
-  |> Jsont.Object.opt_mem "followersCount" Jsont.int ~enc:(fun r -> r.followers_count)
-  |> Jsont.Object.opt_mem "followsCount" Jsont.int ~enc:(fun r -> r.follows_count)
-  |> Jsont.Object.opt_mem "postsCount" Jsont.int ~enc:(fun r -> r.posts_count)
-  |> Jsont.Object.opt_mem "associated" Jsont.json ~enc:(fun r -> r.associated)
-  |> Jsont.Object.opt_mem "joinedViaStarterPack" Jsont.json ~enc:(fun r -> r.joined_via_starter_pack)
+  |> Jsont.Object.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
   |> Jsont.Object.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_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 "status" Jsont.json ~enc:(fun r -> r.status)
   |> Jsont.Object.opt_mem "verification" Jsont.json ~enc:(fun r -> r.verification)
-  |> Jsont.Object.opt_mem "status" Jsont.json ~enc:(fun r -> r.status)
-  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
-  |> Jsont.Object.finish
-
-type viewer_state = {
-  muted : bool option;
-  muted_by_list : Jsont.json option;
-  blocked_by : bool option;
-  blocking : string option;
-  blocking_by_list : Jsont.json option;
-  following : string option;
-  followed_by : string option;
-  known_followers : Jsont.json option;
-  activity_subscription : Jsont.json option;
-}
-
-let viewer_state_jsont =
-  Jsont.Object.map ~kind:"Viewer_state"
-    (fun _typ muted muted_by_list blocked_by blocking blocking_by_list following followed_by known_followers activity_subscription -> { muted; muted_by_list; blocked_by; blocking; blocking_by_list; following; followed_by; known_followers; activity_subscription })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.defs#viewerState" ~enc:(fun _ -> "app.bsky.actor.defs#viewerState")
-  |> Jsont.Object.opt_mem "muted" Jsont.bool ~enc:(fun r -> r.muted)
-  |> Jsont.Object.opt_mem "mutedByList" Jsont.json ~enc:(fun r -> r.muted_by_list)
-  |> Jsont.Object.opt_mem "blockedBy" Jsont.bool ~enc:(fun r -> r.blocked_by)
-  |> Jsont.Object.opt_mem "blocking" Jsont.string ~enc:(fun r -> r.blocking)
-  |> Jsont.Object.opt_mem "blockingByList" Jsont.json ~enc:(fun r -> r.blocking_by_list)
-  |> Jsont.Object.opt_mem "following" Jsont.string ~enc:(fun r -> r.following)
-  |> Jsont.Object.opt_mem "followedBy" Jsont.string ~enc:(fun r -> r.followed_by)
-  |> Jsont.Object.opt_mem "knownFollowers" Jsont.json ~enc:(fun r -> r.known_followers)
-  |> Jsont.Object.opt_mem "activitySubscription" Jsont.json ~enc:(fun r -> r.activity_subscription)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type known_followers = {
···
       end
       module SearchActorsTypeahead = struct
 type params = {
-  term : string option;
-  q : string option;
   limit : int option;
+  q : string option;
+  term : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun term q limit -> {
+    (fun limit q term -> {
+      limit;
+      q;
       term;
-      q;
-      limit;
     })
-  |> Jsont.Object.opt_mem "term" Jsont.string
-       ~enc:(fun r -> r.term)
+  |> 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 "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
+  |> Jsont.Object.opt_mem "term" Jsont.string
+       ~enc:(fun r -> r.term)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module SearchActors = struct
 type params = {
-  term : string option;
-  q : string option;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  q : string option;
+  term : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun term q limit cursor -> {
-      term;
-      q;
+    (fun cursor limit q term -> {
+      cursor;
       limit;
-      cursor;
+      q;
+      term;
     })
-  |> Jsont.Object.opt_mem "term" Jsont.string
-       ~enc:(fun r -> r.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 "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.opt_mem "term" Jsont.string
+       ~enc:(fun r -> r.term)
   |> Jsont.Object.finish
 
 type output = {
-  cursor : string option;
   actors : Jsont.json list;
+  cursor : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor actors -> { cursor; actors })
+    (fun _typ actors cursor -> { actors; cursor })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.actor.searchActors#output" ~enc:(fun _ -> "app.bsky.actor.searchActors#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.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
   |> Jsont.Object.finish
 
       end
       module GetSuggestions = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
+  |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
-  cursor : string option;
   actors : Jsont.json list;
+  cursor : string option;
   rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor actors rec_id -> { cursor; actors; rec_id })
+    (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.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> 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
     module Contact = struct
       module Defs = struct
-type match_and_contact_index = {
-  match_ : Jsont.json;
-  contact_index : int;
-}
-
-let match_and_contact_index_jsont =
-  Jsont.Object.map ~kind:"Match_and_contact_index"
-    (fun _typ match_ contact_index -> { match_; contact_index })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.contact.defs#matchAndContactIndex" ~enc:(fun _ -> "app.bsky.contact.defs#matchAndContactIndex")
-  |> Jsont.Object.mem "match" Jsont.json ~enc:(fun r -> r.match_)
-  |> Jsont.Object.mem "contactIndex" Jsont.int ~enc:(fun r -> r.contact_index)
-  |> Jsont.Object.finish
-
 type sync_status = {
-  synced_at : string;
   matches_count : int;
+  synced_at : string;
 }
 
 let sync_status_jsont =
   Jsont.Object.map ~kind:"Sync_status"
-    (fun _typ synced_at matches_count -> { synced_at; matches_count })
+    (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 "syncedAt" Jsont.string ~enc:(fun r -> r.synced_at)
   |> 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 = {
···
   |> 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
···
       end
       module GetMatches = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
+  |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module VerifyPhone = struct
 type input = {
+  code : string;
   phone : string;
-  code : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ phone code -> { phone; code })
+    (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 "phone" Jsont.string ~enc:(fun r -> r.phone)
   |> 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 = {
···
       end
       module ImportContacts = struct
 type input = {
-  token : string;
   contacts : string list;
+  token : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ token contacts -> { token; contacts })
+    (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.mem "contacts" (Jsont.list Jsont.string) ~enc:(fun r -> r.contacts)
   |> Jsont.Object.finish
 
 type output = {
···
   |> Jsont.Object.finish
 
 type main = {
-  name : string;
+  created_at : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  list_ : string;
   feeds : Jsont.json list option;
-  created_at : string;
+  list_ : string;
+  name : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ name description description_facets list_ feeds created_at -> { name; description; description_facets; list_; feeds; created_at })
+    (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 "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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.mem "list" Jsont.string ~enc:(fun r -> r.list_)
   |> Jsont.Object.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> 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 "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.finish
 
       end
       module GetFollows = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
+      cursor;
       limit;
-      cursor;
     })
   |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   follows : Jsont.json list;
+  subject : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ subject cursor follows -> { subject; cursor; follows })
+    (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.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> 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
···
   |> Jsont.Object.finish
 
 type output = {
-  suggestions : Jsont.json list;
   is_fallback : bool option;
   rec_id : int option;
+  suggestions : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ suggestions is_fallback rec_id -> { suggestions; is_fallback; rec_id })
+    (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.mem "suggestions" (Jsont.list Jsont.json) ~enc:(fun r -> r.suggestions)
   |> 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 Block = struct
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject created_at -> { subject; created_at })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> 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 Listblock = struct
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject created_at -> { subject; created_at })
+    (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.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
       end
···
       module GetFollowers = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
-      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
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ subject cursor followers -> { subject; cursor; followers })
+    (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.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> 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
···
       end
       module Follow = struct
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
   via : Com.Atproto.Repo.StrongRef.main option;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject created_at via -> { subject; created_at; via })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> 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
 
···
       module GetKnownFollowers = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
+      cursor;
       limit;
-      cursor;
     })
   |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ subject cursor followers -> { subject; cursor; followers })
+    (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.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
   |> 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
···
       end
       module Listitem = struct
 type main = {
+  created_at : string;
+  list_ : string;
   subject : string;
-  list_ : string;
-  created_at : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject list_ created_at -> { subject; list_; created_at })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "list" Jsont.string ~enc:(fun r -> r.list_)
   |> 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 Defs = struct
-type list_item_view = {
-  uri : string;
-  subject : Jsont.json;
-}
-
-let list_item_view_jsont =
-  Jsont.Object.map ~kind:"List_item_view"
-    (fun _typ uri subject -> { uri; subject })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listItemView" ~enc:(fun _ -> "app.bsky.graph.defs#listItemView")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "subject" Jsont.json ~enc:(fun r -> r.subject)
-  |> Jsont.Object.finish
-
 type starter_pack_view_basic = {
-  uri : string;
   cid : string;
-  record : Jsont.json;
   creator : Jsont.json;
-  list_item_count : int option;
+  indexed_at : string;
+  joined_all_time_count : int option;
   joined_week_count : int option;
-  joined_all_time_count : int option;
   labels : Com.Atproto.Label.Defs.label list option;
-  indexed_at : string;
+  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 uri cid record creator list_item_count joined_week_count joined_all_time_count labels indexed_at -> { uri; cid; record; creator; list_item_count; joined_week_count; joined_all_time_count; labels; indexed_at })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
+  |> 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 "joinedAllTimeCount" Jsont.int ~enc:(fun r -> r.joined_all_time_count)
   |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> 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 list_purpose = string
-let list_purpose_jsont = Jsont.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;
+}
 
-type modlist = string
-let modlist_jsont = Jsont.string
-
-type curatelist = string
-let curatelist_jsont = Jsont.string
+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 list_viewer_state = {
-  muted : bool option;
-  blocked : string option;
-}
-
-let list_viewer_state_jsont =
-  Jsont.Object.map ~kind:"List_viewer_state"
-    (fun _typ muted blocked -> { muted; blocked })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#listViewerState" ~enc:(fun _ -> "app.bsky.graph.defs#listViewerState")
-  |> Jsont.Object.opt_mem "muted" Jsont.bool ~enc:(fun r -> r.muted)
-  |> Jsont.Object.opt_mem "blocked" Jsont.string ~enc:(fun r -> r.blocked)
-  |> Jsont.Object.finish
-
 type not_found_actor = {
   actor : string;
   not_found : bool;
···
   |> Jsont.Object.mem "notFound" Jsont.bool ~enc:(fun r -> r.not_found)
   |> Jsont.Object.finish
 
-type relationship = {
-  did : string;
-  following : string option;
-  followed_by : string option;
-  blocking : string option;
-  blocked_by : string option;
-  blocking_by_list : string option;
-  blocked_by_list : string option;
+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 relationship_jsont =
-  Jsont.Object.map ~kind:"Relationship"
-    (fun _typ did following followed_by blocking blocked_by blocking_by_list blocked_by_list -> { did; following; followed_by; blocking; blocked_by; blocking_by_list; blocked_by_list })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.graph.defs#relationship" ~enc:(fun _ -> "app.bsky.graph.defs#relationship")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.opt_mem "following" Jsont.string ~enc:(fun r -> r.following)
-  |> Jsont.Object.opt_mem "followedBy" Jsont.string ~enc:(fun r -> r.followed_by)
-  |> Jsont.Object.opt_mem "blocking" Jsont.string ~enc:(fun r -> r.blocking)
-  |> Jsont.Object.opt_mem "blockedBy" Jsont.string ~enc:(fun r -> r.blocked_by)
-  |> Jsont.Object.opt_mem "blockingByList" Jsont.string ~enc:(fun r -> r.blocking_by_list)
-  |> Jsont.Object.opt_mem "blockedByList" Jsont.string ~enc:(fun r -> r.blocked_by_list)
+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 = {
-  uri : string;
+  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;
-  avatar : string option;
-  list_item_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
+  uri : string;
   viewer : Jsont.json option;
-  indexed_at : string option;
 }
 
 let list_view_basic_jsont =
   Jsont.Object.map ~kind:"List_view_basic"
-    (fun _typ uri cid name purpose avatar list_item_count labels viewer indexed_at -> { uri; cid; name; purpose; avatar; list_item_count; labels; viewer; indexed_at })
+    (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.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> 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.opt_mem "avatar" Jsont.string ~enc:(fun r -> r.avatar)
-  |> Jsont.Object.opt_mem "listItemCount" Jsont.int ~enc:(fun r -> r.list_item_count)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> 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.opt_mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.finish
 
 type list_view = {
-  uri : string;
+  avatar : string option;
   cid : string;
   creator : Jsont.json;
-  name : string;
-  purpose : Jsont.json;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : string option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
   list_item_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
+  name : string;
+  purpose : Jsont.json;
+  uri : string;
   viewer : Jsont.json option;
-  indexed_at : string;
 }
 
 let list_view_jsont =
   Jsont.Object.map ~kind:"List_view"
-    (fun _typ uri cid creator name purpose description description_facets avatar list_item_count labels viewer indexed_at -> { uri; cid; creator; name; purpose; description; description_facets; avatar; list_item_count; labels; viewer; indexed_at })
+    (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.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> 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.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
   |> 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 "avatar" Jsont.string ~enc:(fun r -> r.avatar)
+  |> 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.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_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.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.finish
 
 type starter_pack_view = {
-  uri : string;
   cid : string;
-  record : Jsont.json;
   creator : Jsont.json;
-  list_ : Jsont.json option;
-  list_items_sample : Jsont.json list option;
   feeds : Jsont.json list option;
-  joined_week_count : int option;
+  indexed_at : string;
   joined_all_time_count : int option;
+  joined_week_count : int option;
   labels : Com.Atproto.Label.Defs.label list option;
-  indexed_at : string;
+  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 uri cid record creator list_ list_items_sample feeds joined_week_count joined_all_time_count labels indexed_at -> { uri; cid; record; creator; list_; list_items_sample; feeds; joined_week_count; joined_all_time_count; labels; indexed_at })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> 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.opt_mem "feeds" (Jsont.list Jsont.json) ~enc:(fun r -> r.feeds)
-  |> Jsont.Object.opt_mem "joinedWeekCount" Jsont.int ~enc:(fun r -> r.joined_week_count)
+  |> 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.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> 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 GetBlocks = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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;
   blocks : Jsont.json list;
+  cursor : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor blocks -> { cursor; blocks })
+    (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.mem "blocks" (Jsont.list Jsont.json) ~enc:(fun r -> r.blocks)
   |> Jsont.Object.finish
 
       end
       module Verification = struct
 type main = {
-  subject : string;
+  created_at : string;
+  display_name : string;
   handle : string;
-  display_name : string;
-  created_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject handle display_name created_at -> { subject; handle; display_name; created_at })
+    (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.mem "handle" Jsont.string ~enc:(fun r -> r.handle)
-  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
       end
       module GetMutes = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
+  |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetStarterPacksWithMembership = struct
 type starter_pack_with_membership = {
-  starter_pack : Jsont.json;
   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 starter_pack list_item -> { starter_pack; list_item })
+    (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.opt_mem "listItem" Jsont.json ~enc:(fun r -> r.list_item)
   |> Jsont.Object.finish
 
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
-      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
        ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       module GetActorStarterPacks = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
+      cursor;
       limit;
-      cursor;
     })
   |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module List = struct
 type main = {
-  purpose : Jsont.json;
-  name : string;
+  avatar : Atp.Blob_ref.t option;
+  created_at : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : Atp.Blob_ref.t option;
   labels : Com.Atproto.Label.Defs.self_labels option;
-  created_at : string;
+  name : string;
+  purpose : Jsont.json;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ purpose name description description_facets avatar labels created_at -> { purpose; name; description; description_facets; avatar; labels; created_at })
+    (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.mem "purpose" Jsont.json ~enc:(fun r -> r.purpose)
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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 "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
   |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> 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
       module SearchStarterPacks = struct
 type params = {
-  q : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  q : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun q limit cursor -> {
-      q;
+    (fun cursor limit q -> {
+      cursor;
       limit;
-      cursor;
+      q;
     })
-  |> Jsont.Object.mem "q" Jsont.string
-       ~enc:(fun r -> r.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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "q" Jsont.string
+       ~enc:(fun r -> r.q)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetList = struct
 type params = {
-  list_ : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  list_ : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun list_ limit cursor -> {
+    (fun cursor limit list_ -> {
+      cursor;
+      limit;
       list_;
-      limit;
-      cursor;
     })
+  |> 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 "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
   cursor : string option;
+  items : Jsont.json list;
   list_ : Jsont.json;
-  items : Jsont.json list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor list_ items -> { cursor; list_; items })
+    (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 "list" Jsont.json ~enc:(fun r -> r.list_)
   |> 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 GetListBlocks = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
-      limit;
+    (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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
 
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
   purposes : string list option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor purposes -> {
+    (fun actor cursor limit purposes -> {
       actor;
-      limit;
       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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
        ~enc:(fun r -> r.purposes)
   |> Jsont.Object.finish
···
       end
       module GetListMutes = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
-      limit;
+    (fun cursor limit -> {
       cursor;
+      limit;
     })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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 = {
···
       module GetLists = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
   purposes : string list option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor purposes -> {
+    (fun actor cursor limit purposes -> {
       actor;
-      limit;
       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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "purposes" (Jsont.list Jsont.string)
        ~enc:(fun r -> r.purposes)
   |> Jsont.Object.finish
···
     end
     module Feed = struct
       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;
-  parent : Com.Atproto.Repo.StrongRef.main;
 }
 
 let reply_ref_jsont =
   Jsont.Object.map ~kind:"Reply_ref"
-    (fun _typ root parent -> { root; parent })
+    (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 "root" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.root)
   |> Jsont.Object.mem "parent" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.parent)
-  |> Jsont.Object.finish
-
-type text_slice = {
-  start : int;
-  end_ : int;
-}
-
-let text_slice_jsont =
-  Jsont.Object.map ~kind:"Text_slice"
-    (fun _typ start end_ -> { start; end_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.post#textSlice" ~enc:(fun _ -> "app.bsky.feed.post#textSlice")
-  |> Jsont.Object.mem "start" Jsont.int ~enc:(fun r -> r.start)
-  |> Jsont.Object.mem "end" Jsont.int ~enc:(fun r -> r.end_)
+  |> Jsont.Object.mem "root" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.root)
   |> Jsont.Object.finish
 
 type entity = {
···
   |> Jsont.Object.finish
 
 type main = {
-  text : string;
+  created_at : string;
+  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;
-  embed : Jsont.json option;
-  langs : string list option;
-  labels : Com.Atproto.Label.Defs.self_labels option;
   tags : string list option;
-  created_at : string;
+  text : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ text entities facets reply embed langs labels tags created_at -> { text; entities; facets; reply; embed; langs; labels; tags; created_at })
+    (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 "text" Jsont.string ~enc:(fun r -> r.text)
+  |> 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 "reply" Jsont.json ~enc:(fun r -> r.reply)
-  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
+  |> 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 "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> 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 "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "text" Jsont.string ~enc:(fun r -> r.text)
   |> Jsont.Object.finish
 
       end
       module GetLikes = struct
 type like = {
-  indexed_at : string;
-  created_at : string;
   actor : Jsont.json;
+  created_at : string;
+  indexed_at : string;
 }
 
 let like_jsont =
   Jsont.Object.map ~kind:"Like"
-    (fun _typ indexed_at created_at actor -> { indexed_at; created_at; actor })
+    (fun _typ actor created_at indexed_at -> { actor; created_at; indexed_at })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getLikes#like" ~enc:(fun _ -> "app.bsky.feed.getLikes#like")
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.mem "actor" Jsont.json ~enc:(fun r -> r.actor)
   |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "actor" Jsont.json ~enc:(fun r -> r.actor)
+  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.finish
 
 type params = {
-  uri : string;
   cid : string option;
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun uri cid limit cursor -> {
-      uri;
+    (fun cid cursor limit uri -> {
       cid;
+      cursor;
       limit;
-      cursor;
+      uri;
     })
-  |> Jsont.Object.mem "uri" Jsont.string
-       ~enc:(fun r -> r.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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "uri" Jsont.string
+       ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   likes : Jsont.json list;
+  uri : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid cursor likes -> { uri; cid; cursor; likes })
+    (fun _typ cid cursor likes uri -> { cid; cursor; likes; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getLikes#output" ~enc:(fun _ -> "app.bsky.feed.getLikes#output")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.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.mem "likes" (Jsont.list Jsont.json) ~enc:(fun r -> r.likes)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
       end
···
 
 type main = {
   created_at : string;
-  post : 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 post detached_embedding_uris embedding_rules -> { created_at; post; detached_embedding_uris; embedding_rules })
+    (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.mem "post" Jsont.string ~enc:(fun r -> r.post)
   |> 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 = {
-  uri : string;
   cid : string option;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun uri cid limit cursor -> {
-      uri;
+    (fun cid cursor limit uri -> {
       cid;
+      cursor;
       limit;
-      cursor;
+      uri;
     })
-  |> Jsont.Object.mem "uri" Jsont.string
-       ~enc:(fun r -> r.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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "uri" Jsont.string
+       ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   reposted_by : Jsont.json list;
+  uri : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid cursor reposted_by -> { uri; cid; cursor; reposted_by })
+    (fun _typ cid cursor reposted_by uri -> { cid; cursor; reposted_by; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.getRepostedBy#output" ~enc:(fun _ -> "app.bsky.feed.getRepostedBy#output")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.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.mem "repostedBy" (Jsont.list Jsont.json) ~enc:(fun r -> r.reposted_by)
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
       end
       module DescribeFeedGenerator = struct
-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 links = {
   privacy_policy : string option;
   terms_of_service : string option;
···
   |> 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;
   feeds : Jsont.json list;
···
 
 let mention_rule_jsont = Jsont.ignore
 
-type follower_rule = unit
-
-let follower_rule_jsont = Jsont.ignore
-
-type following_rule = unit
-
-let following_rule_jsont = Jsont.ignore
-
 type list_rule = {
   list_ : string;
 }
···
   |> 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 = {
-  post : string;
   allow : Jsont.json list option;
   created_at : string;
   hidden_replies : string list option;
+  post : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ post allow created_at hidden_replies -> { post; allow; created_at; hidden_replies })
+    (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.mem "post" Jsont.string ~enc:(fun r -> r.post)
   |> 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)
   |> Jsont.Object.finish
 
       end
       module Like = struct
 type main = {
-  subject : Com.Atproto.Repo.StrongRef.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 subject created_at via -> { subject; created_at; via })
+    (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.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.opt_mem "via" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.via)
   |> Jsont.Object.finish
 
       end
       module Defs = struct
 type viewer_state = {
-  repost : string option;
-  like : string option;
   bookmarked : bool option;
-  thread_muted : bool option;
-  reply_disabled : bool option;
   embedding_disabled : bool option;
+  like : string option;
   pinned : bool option;
+  reply_disabled : bool option;
+  repost : string option;
+  thread_muted : bool option;
 }
 
 let viewer_state_jsont =
   Jsont.Object.map ~kind:"Viewer_state"
-    (fun _typ repost like bookmarked thread_muted reply_disabled embedding_disabled pinned -> { repost; like; bookmarked; thread_muted; reply_disabled; embedding_disabled; pinned })
+    (fun _typ bookmarked embedding_disabled like pinned reply_disabled repost thread_muted -> { bookmarked; embedding_disabled; like; pinned; reply_disabled; repost; thread_muted })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#viewerState" ~enc:(fun _ -> "app.bsky.feed.defs#viewerState")
-  |> Jsont.Object.opt_mem "repost" Jsont.string ~enc:(fun r -> r.repost)
-  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
   |> Jsont.Object.opt_mem "bookmarked" Jsont.bool ~enc:(fun r -> r.bookmarked)
-  |> Jsont.Object.opt_mem "threadMuted" Jsont.bool ~enc:(fun r -> r.thread_muted)
-  |> Jsont.Object.opt_mem "replyDisabled" Jsont.bool ~enc:(fun r -> r.reply_disabled)
   |> Jsont.Object.opt_mem "embeddingDisabled" Jsont.bool ~enc:(fun r -> r.embedding_disabled)
+  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
   |> Jsont.Object.opt_mem "pinned" Jsont.bool ~enc:(fun r -> r.pinned)
+  |> Jsont.Object.opt_mem "replyDisabled" Jsont.bool ~enc:(fun r -> r.reply_disabled)
+  |> Jsont.Object.opt_mem "repost" Jsont.string ~enc:(fun r -> r.repost)
+  |> Jsont.Object.opt_mem "threadMuted" Jsont.bool ~enc:(fun r -> r.thread_muted)
+  |> Jsont.Object.finish
+
+type threadgate_view = {
+  cid : string option;
+  lists : Jsont.json list option;
+  record : Jsont.json option;
+  uri : string option;
+}
+
+let threadgate_view_jsont =
+  Jsont.Object.map ~kind:"Threadgate_view"
+    (fun _typ cid lists record uri -> { cid; lists; record; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#threadgateView" ~enc:(fun _ -> "app.bsky.feed.defs#threadgateView")
+  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.opt_mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
+  |> Jsont.Object.opt_mem "record" Jsont.json ~enc:(fun r -> r.record)
+  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type thread_context = {
···
   |> Jsont.Object.opt_mem "rootAuthorLike" Jsont.string ~enc:(fun r -> r.root_author_like)
   |> Jsont.Object.finish
 
+type skeleton_reason_repost = {
+  repost : string;
+}
+
+let skeleton_reason_repost_jsont =
+  Jsont.Object.map ~kind:"Skeleton_reason_repost"
+    (fun _typ repost -> { repost })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#skeletonReasonRepost" ~enc:(fun _ -> "app.bsky.feed.defs#skeletonReasonRepost")
+  |> Jsont.Object.mem "repost" Jsont.string ~enc:(fun r -> r.repost)
+  |> Jsont.Object.finish
+
+type skeleton_reason_pin = unit
+
+let skeleton_reason_pin_jsont = Jsont.ignore
+
+type skeleton_feed_post = {
+  feed_context : string option;
+  post : string;
+  reason : Jsont.json option;
+}
+
+let skeleton_feed_post_jsont =
+  Jsont.Object.map ~kind:"Skeleton_feed_post"
+    (fun _typ feed_context post reason -> { feed_context; post; reason })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#skeletonFeedPost" ~enc:(fun _ -> "app.bsky.feed.defs#skeletonFeedPost")
+  |> Jsont.Object.opt_mem "feedContext" Jsont.string ~enc:(fun r -> r.feed_context)
+  |> Jsont.Object.mem "post" Jsont.string ~enc:(fun r -> r.post)
+  |> Jsont.Object.opt_mem "reason" Jsont.json ~enc:(fun r -> r.reason)
+  |> Jsont.Object.finish
+
+type request_more = string
+let request_more_jsont = Jsont.string
+
+type request_less = string
+let request_less_jsont = Jsont.string
+
 type reply_ref = {
-  root : Jsont.json;
-  parent : Jsont.json;
   grandparent_author : Jsont.json option;
+  parent : Jsont.json;
+  root : Jsont.json;
 }
 
 let reply_ref_jsont =
   Jsont.Object.map ~kind:"Reply_ref"
-    (fun _typ root parent grandparent_author -> { root; parent; grandparent_author })
+    (fun _typ grandparent_author parent root -> { grandparent_author; parent; root })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#replyRef" ~enc:(fun _ -> "app.bsky.feed.defs#replyRef")
-  |> Jsont.Object.mem "root" Jsont.json ~enc:(fun r -> r.root)
+  |> Jsont.Object.opt_mem "grandparentAuthor" Jsont.json ~enc:(fun r -> r.grandparent_author)
   |> Jsont.Object.mem "parent" Jsont.json ~enc:(fun r -> r.parent)
-  |> Jsont.Object.opt_mem "grandparentAuthor" Jsont.json ~enc:(fun r -> r.grandparent_author)
+  |> Jsont.Object.mem "root" Jsont.json ~enc:(fun r -> r.root)
   |> Jsont.Object.finish
 
 type reason_repost = {
   by : Jsont.json;
-  uri : string option;
   cid : string option;
   indexed_at : string;
+  uri : string option;
 }
 
 let reason_repost_jsont =
   Jsont.Object.map ~kind:"Reason_repost"
-    (fun _typ by uri cid indexed_at -> { by; uri; cid; indexed_at })
+    (fun _typ by cid indexed_at uri -> { by; cid; indexed_at; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#reasonRepost" ~enc:(fun _ -> "app.bsky.feed.defs#reasonRepost")
   |> Jsont.Object.mem "by" Jsont.json ~enc:(fun r -> r.by)
-  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
+  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type reason_pin = unit
···
 let reason_pin_jsont = Jsont.ignore
 
 type not_found_post = {
+  not_found : bool;
   uri : string;
-  not_found : bool;
 }
 
 let not_found_post_jsont =
   Jsont.Object.map ~kind:"Not_found_post"
-    (fun _typ uri not_found -> { uri; not_found })
+    (fun _typ not_found uri -> { not_found; uri })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#notFoundPost" ~enc:(fun _ -> "app.bsky.feed.defs#notFoundPost")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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 blocked_author = {
-  did : string;
-  viewer : Jsont.json option;
-}
+type interaction_share = string
+let interaction_share_jsont = Jsont.string
 
-let blocked_author_jsont =
-  Jsont.Object.map ~kind:"Blocked_author"
-    (fun _typ did viewer -> { did; viewer })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#blockedAuthor" ~enc:(fun _ -> "app.bsky.feed.defs#blockedAuthor")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.finish
-
-type generator_viewer_state = {
-  like : string option;
-}
-
-let generator_viewer_state_jsont =
-  Jsont.Object.map ~kind:"Generator_viewer_state"
-    (fun _typ like -> { like })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#generatorViewerState" ~enc:(fun _ -> "app.bsky.feed.defs#generatorViewerState")
-  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
-  |> Jsont.Object.finish
-
-type skeleton_feed_post = {
-  post : string;
-  reason : Jsont.json option;
-  feed_context : string option;
-}
-
-let skeleton_feed_post_jsont =
-  Jsont.Object.map ~kind:"Skeleton_feed_post"
-    (fun _typ post reason feed_context -> { post; reason; feed_context })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#skeletonFeedPost" ~enc:(fun _ -> "app.bsky.feed.defs#skeletonFeedPost")
-  |> Jsont.Object.mem "post" Jsont.string ~enc:(fun r -> r.post)
-  |> Jsont.Object.opt_mem "reason" Jsont.json ~enc:(fun r -> r.reason)
-  |> Jsont.Object.opt_mem "feedContext" Jsont.string ~enc:(fun r -> r.feed_context)
-  |> Jsont.Object.finish
-
-type skeleton_reason_repost = {
-  repost : string;
-}
+type interaction_seen = string
+let interaction_seen_jsont = Jsont.string
 
-let skeleton_reason_repost_jsont =
-  Jsont.Object.map ~kind:"Skeleton_reason_repost"
-    (fun _typ repost -> { repost })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#skeletonReasonRepost" ~enc:(fun _ -> "app.bsky.feed.defs#skeletonReasonRepost")
-  |> Jsont.Object.mem "repost" Jsont.string ~enc:(fun r -> r.repost)
-  |> Jsont.Object.finish
+type interaction_repost = string
+let interaction_repost_jsont = Jsont.string
 
-type skeleton_reason_pin = unit
-
-let skeleton_reason_pin_jsont = Jsont.ignore
+type interaction_reply = string
+let interaction_reply_jsont = Jsont.string
 
-type threadgate_view = {
-  uri : string option;
-  cid : string option;
-  record : Jsont.json option;
-  lists : Jsont.json list option;
-}
+type interaction_quote = string
+let interaction_quote_jsont = Jsont.string
 
-let threadgate_view_jsont =
-  Jsont.Object.map ~kind:"Threadgate_view"
-    (fun _typ uri cid record lists -> { uri; cid; record; lists })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#threadgateView" ~enc:(fun _ -> "app.bsky.feed.defs#threadgateView")
-  |> Jsont.Object.opt_mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.opt_mem "cid" Jsont.string ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.opt_mem "lists" (Jsont.list Jsont.json) ~enc:(fun r -> r.lists)
-  |> Jsont.Object.finish
+type interaction_like = string
+let interaction_like_jsont = Jsont.string
 
 type interaction = {
-  item : string option;
   event : string option;
   feed_context : string option;
+  item : string option;
   req_id : string option;
 }
 
 let interaction_jsont =
   Jsont.Object.map ~kind:"Interaction"
-    (fun _typ item event feed_context req_id -> { item; event; feed_context; req_id })
+    (fun _typ event feed_context item req_id -> { event; feed_context; item; req_id })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#interaction" ~enc:(fun _ -> "app.bsky.feed.defs#interaction")
-  |> Jsont.Object.opt_mem "item" Jsont.string ~enc:(fun r -> r.item)
   |> Jsont.Object.opt_mem "event" Jsont.string ~enc:(fun r -> r.event)
   |> Jsont.Object.opt_mem "feedContext" Jsont.string ~enc:(fun r -> r.feed_context)
+  |> Jsont.Object.opt_mem "item" Jsont.string ~enc:(fun r -> r.item)
   |> Jsont.Object.opt_mem "reqId" Jsont.string ~enc:(fun r -> r.req_id)
   |> Jsont.Object.finish
 
-type request_less = string
-let request_less_jsont = Jsont.string
+type generator_viewer_state = {
+  like : string option;
+}
 
-type request_more = string
-let request_more_jsont = Jsont.string
+let generator_viewer_state_jsont =
+  Jsont.Object.map ~kind:"Generator_viewer_state"
+    (fun _typ like -> { like })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#generatorViewerState" ~enc:(fun _ -> "app.bsky.feed.defs#generatorViewerState")
+  |> Jsont.Object.opt_mem "like" Jsont.string ~enc:(fun r -> r.like)
+  |> Jsont.Object.finish
 
-type clickthrough_item = string
-let clickthrough_item_jsont = Jsont.string
+type content_mode_video = string
+let content_mode_video_jsont = Jsont.string
 
-type clickthrough_author = string
-let clickthrough_author_jsont = Jsont.string
+type content_mode_unspecified = string
+let content_mode_unspecified_jsont = Jsont.string
 
 type clickthrough_reposter = string
 let clickthrough_reposter_jsont = Jsont.string
 
+type clickthrough_item = string
+let clickthrough_item_jsont = Jsont.string
+
 type clickthrough_embed = string
 let clickthrough_embed_jsont = Jsont.string
 
-type content_mode_unspecified = string
-let content_mode_unspecified_jsont = Jsont.string
+type clickthrough_author = string
+let clickthrough_author_jsont = Jsont.string
 
-type content_mode_video = string
-let content_mode_video_jsont = Jsont.string
-
-type interaction_seen = string
-let interaction_seen_jsont = Jsont.string
-
-type interaction_like = string
-let interaction_like_jsont = Jsont.string
-
-type interaction_repost = string
-let interaction_repost_jsont = Jsont.string
+type blocked_author = {
+  did : string;
+  viewer : Jsont.json option;
+}
 
-type interaction_reply = string
-let interaction_reply_jsont = Jsont.string
-
-type interaction_quote = string
-let interaction_quote_jsont = Jsont.string
-
-type interaction_share = string
-let interaction_share_jsont = Jsont.string
+let blocked_author_jsont =
+  Jsont.Object.map ~kind:"Blocked_author"
+    (fun _typ did viewer -> { did; viewer })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#blockedAuthor" ~enc:(fun _ -> "app.bsky.feed.defs#blockedAuthor")
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
+  |> Jsont.Object.finish
 
 type post_view = {
-  uri : string;
-  cid : string;
   author : Jsont.json;
-  record : Jsont.json;
-  embed : Jsont.json option;
   bookmark_count : int option;
-  reply_count : int option;
-  repost_count : int option;
-  like_count : int option;
-  quote_count : int option;
+  cid : string;
+  debug : Jsont.json option;
+  embed : Jsont.json option;
   indexed_at : string;
-  viewer : Jsont.json option;
   labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  quote_count : int option;
+  record : Jsont.json;
+  reply_count : int option;
+  repost_count : int option;
   threadgate : Jsont.json option;
-  debug : Jsont.json option;
+  uri : string;
+  viewer : Jsont.json option;
 }
 
 let post_view_jsont =
   Jsont.Object.map ~kind:"Post_view"
-    (fun _typ uri cid author record embed bookmark_count reply_count repost_count like_count quote_count indexed_at viewer labels threadgate debug -> { uri; cid; author; record; embed; bookmark_count; reply_count; repost_count; like_count; quote_count; indexed_at; viewer; labels; threadgate; debug })
+    (fun _typ author bookmark_count cid debug embed indexed_at labels like_count quote_count record reply_count repost_count threadgate uri viewer -> { author; bookmark_count; cid; debug; embed; indexed_at; labels; like_count; quote_count; record; reply_count; repost_count; threadgate; uri; viewer })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#postView" ~enc:(fun _ -> "app.bsky.feed.defs#postView")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
-  |> Jsont.Object.mem "record" Jsont.json ~enc:(fun r -> r.record)
-  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
   |> Jsont.Object.opt_mem "bookmarkCount" Jsont.int ~enc:(fun r -> r.bookmark_count)
+  |> Jsont.Object.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
+  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
+  |> Jsont.Object.opt_mem "embed" Jsont.json ~enc:(fun r -> r.embed)
+  |> 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.mem "record" Jsont.json ~enc:(fun r -> r.record)
   |> 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 "likeCount" Jsont.int ~enc:(fun r -> r.like_count)
-  |> Jsont.Object.opt_mem "quoteCount" Jsont.int ~enc:(fun r -> r.quote_count)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
-  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
   |> Jsont.Object.opt_mem "threadgate" Jsont.json ~enc:(fun r -> r.threadgate)
-  |> Jsont.Object.opt_mem "debug" Jsont.json ~enc:(fun r -> r.debug)
-  |> Jsont.Object.finish
-
-type blocked_post = {
-  uri : string;
-  blocked : bool;
-  author : Jsont.json;
-}
-
-let blocked_post_jsont =
-  Jsont.Object.map ~kind:"Blocked_post"
-    (fun _typ uri blocked author -> { uri; blocked; author })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#blockedPost" ~enc:(fun _ -> "app.bsky.feed.defs#blockedPost")
   |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.mem "blocked" Jsont.bool ~enc:(fun r -> r.blocked)
-  |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
+  |> Jsont.Object.opt_mem "viewer" Jsont.json ~enc:(fun r -> r.viewer)
   |> Jsont.Object.finish
 
 type generator_view = {
-  uri : string;
+  accepts_interactions : bool option;
+  avatar : string option;
   cid : string;
-  did : string;
+  content_mode : string option;
   creator : Jsont.json;
-  display_name : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : string option;
+  did : string;
+  display_name : string;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
   like_count : int option;
-  accepts_interactions : bool option;
-  labels : Com.Atproto.Label.Defs.label list option;
+  uri : string;
   viewer : Jsont.json option;
-  content_mode : string option;
-  indexed_at : string;
 }
 
 let generator_view_jsont =
   Jsont.Object.map ~kind:"Generator_view"
-    (fun _typ uri cid did creator display_name description description_facets avatar like_count accepts_interactions labels viewer content_mode indexed_at -> { uri; cid; did; creator; display_name; description; description_facets; avatar; like_count; accepts_interactions; labels; viewer; content_mode; indexed_at })
+    (fun _typ accepts_interactions avatar cid content_mode creator description description_facets did display_name indexed_at labels like_count uri viewer -> { accepts_interactions; avatar; cid; content_mode; creator; description; description_facets; did; display_name; indexed_at; labels; like_count; uri; viewer })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#generatorView" ~enc:(fun _ -> "app.bsky.feed.defs#generatorView")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.opt_mem "acceptsInteractions" Jsont.bool ~enc:(fun r -> r.accepts_interactions)
+  |> 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 "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.opt_mem "contentMode" Jsont.string ~enc:(fun r -> r.content_mode)
   |> Jsont.Object.mem "creator" Jsont.json ~enc:(fun r -> r.creator)
-  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
   |> 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 "avatar" Jsont.string ~enc:(fun r -> r.avatar)
+  |> 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.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 "acceptsInteractions" Jsont.bool ~enc:(fun r -> r.accepts_interactions)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Com.Atproto.Label.Defs.label_jsont) ~enc:(fun r -> r.labels)
+  |> 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.opt_mem "contentMode" Jsont.string ~enc:(fun r -> r.content_mode)
-  |> Jsont.Object.mem "indexedAt" Jsont.string ~enc:(fun r -> r.indexed_at)
   |> Jsont.Object.finish
 
-type feed_view_post = {
-  post : Jsont.json;
-  reply : Jsont.json option;
-  reason : Jsont.json option;
-  feed_context : string option;
-  req_id : string option;
+type blocked_post = {
+  author : Jsont.json;
+  blocked : bool;
+  uri : string;
 }
 
-let feed_view_post_jsont =
-  Jsont.Object.map ~kind:"Feed_view_post"
-    (fun _typ post reply reason feed_context req_id -> { post; reply; reason; feed_context; req_id })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#feedViewPost" ~enc:(fun _ -> "app.bsky.feed.defs#feedViewPost")
-  |> Jsont.Object.mem "post" Jsont.json ~enc:(fun r -> r.post)
-  |> Jsont.Object.opt_mem "reply" Jsont.json ~enc:(fun r -> r.reply)
-  |> Jsont.Object.opt_mem "reason" Jsont.json ~enc:(fun r -> r.reason)
-  |> Jsont.Object.opt_mem "feedContext" Jsont.string ~enc:(fun r -> r.feed_context)
-  |> Jsont.Object.opt_mem "reqId" Jsont.string ~enc:(fun r -> r.req_id)
+let blocked_post_jsont =
+  Jsont.Object.map ~kind:"Blocked_post"
+    (fun _typ author blocked uri -> { author; blocked; uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#blockedPost" ~enc:(fun _ -> "app.bsky.feed.defs#blockedPost")
+  |> 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 thread_view_post = {
-  post : Jsont.json;
   parent : Jsont.json option;
+  post : Jsont.json;
   replies : Jsont.json list option;
   thread_context : Jsont.json option;
 }
 
 let thread_view_post_jsont =
   Jsont.Object.map ~kind:"Thread_view_post"
-    (fun _typ post parent replies thread_context -> { post; parent; replies; thread_context })
+    (fun _typ parent post replies thread_context -> { parent; post; replies; thread_context })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#threadViewPost" ~enc:(fun _ -> "app.bsky.feed.defs#threadViewPost")
+  |> Jsont.Object.opt_mem "parent" Jsont.json ~enc:(fun r -> r.parent)
   |> Jsont.Object.mem "post" Jsont.json ~enc:(fun r -> r.post)
-  |> Jsont.Object.opt_mem "parent" Jsont.json ~enc:(fun r -> r.parent)
   |> Jsont.Object.opt_mem "replies" (Jsont.list Jsont.json) ~enc:(fun r -> r.replies)
   |> Jsont.Object.opt_mem "threadContext" Jsont.json ~enc:(fun r -> r.thread_context)
   |> Jsont.Object.finish
 
+type feed_view_post = {
+  feed_context : string option;
+  post : Jsont.json;
+  reason : Jsont.json option;
+  reply : Jsont.json option;
+  req_id : string option;
+}
+
+let feed_view_post_jsont =
+  Jsont.Object.map ~kind:"Feed_view_post"
+    (fun _typ feed_context post reason reply req_id -> { feed_context; post; reason; reply; req_id })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.feed.defs#feedViewPost" ~enc:(fun _ -> "app.bsky.feed.defs#feedViewPost")
+  |> Jsont.Object.opt_mem "feedContext" Jsont.string ~enc:(fun r -> r.feed_context)
+  |> Jsont.Object.mem "post" Jsont.json ~enc:(fun r -> r.post)
+  |> Jsont.Object.opt_mem "reason" Jsont.json ~enc:(fun r -> r.reason)
+  |> Jsont.Object.opt_mem "reply" Jsont.json ~enc:(fun r -> r.reply)
+  |> Jsont.Object.opt_mem "reqId" Jsont.string ~enc:(fun r -> r.req_id)
+  |> Jsont.Object.finish
+
       end
       module Repost = struct
 type main = {
-  subject : Com.Atproto.Repo.StrongRef.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 subject created_at via -> { subject; created_at; via })
+    (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 "subject" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.subject)
   |> 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;
+  description : string option;
+  description_facets : Richtext.Facet.main list option;
   did : string;
   display_name : string;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  avatar : Atp.Blob_ref.t option;
-  accepts_interactions : bool option;
   labels : Com.Atproto.Label.Defs.self_labels option;
-  content_mode : string option;
-  created_at : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ did display_name description description_facets avatar accepts_interactions labels content_mode created_at -> { did; display_name; description; description_facets; avatar; accepts_interactions; labels; content_mode; created_at })
+    (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.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 "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 "avatar" Atp.Blob_ref.jsont ~enc:(fun r -> r.avatar)
   |> Jsont.Object.opt_mem "acceptsInteractions" Jsont.bool ~enc:(fun r -> r.accepts_interactions)
-  |> Jsont.Object.opt_mem "labels" Com.Atproto.Label.Defs.self_labels_jsont ~enc:(fun r -> r.labels)
+  |> 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)
+  |> 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.finish
 
       end
       module GetPostThread = struct
 type params = {
-  uri : string;
   depth : int option;
   parent_height : int option;
+  uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun uri depth parent_height -> {
-      uri;
+    (fun depth parent_height uri -> {
       depth;
       parent_height;
+      uri;
     })
-  |> Jsont.Object.mem "uri" Jsont.string
-       ~enc:(fun r -> r.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 = {
···
       end
       module GetFeed = struct
 type params = {
+  cursor : string option;
   feed : string;
   limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun feed limit cursor -> {
+    (fun cursor feed limit -> {
+      cursor;
       feed;
       limit;
-      cursor;
     })
+  |> 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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetQuotes = struct
 type params = {
-  uri : string;
   cid : string option;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  uri : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun uri cid limit cursor -> {
-      uri;
+    (fun cid cursor limit uri -> {
       cid;
+      cursor;
       limit;
-      cursor;
+      uri;
     })
-  |> Jsont.Object.mem "uri" Jsont.string
-       ~enc:(fun r -> r.uri)
   |> Jsont.Object.opt_mem "cid" Jsont.string
        ~enc:(fun r -> r.cid)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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.mem "uri" Jsont.string
+       ~enc:(fun r -> r.uri)
   |> Jsont.Object.finish
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   posts : Jsont.json list;
+  uri : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ uri cid cursor posts -> { uri; cid; cursor; posts })
+    (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.mem "uri" Jsont.string ~enc:(fun r -> r.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.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
       module GetListFeed = struct
 type params = {
-  list_ : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  list_ : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun list_ limit cursor -> {
+    (fun cursor limit list_ -> {
+      cursor;
+      limit;
       list_;
-      limit;
-      cursor;
     })
+  |> 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 "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       module GetActorLikes = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
-      limit;
       cursor;
+      limit;
     })
   |> Jsont.Object.mem "actor" Jsont.string
        ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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 = {
···
       end
       module GetFeedSkeleton = struct
 type params = {
+  cursor : string option;
   feed : string;
   limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun feed limit cursor -> {
+    (fun cursor feed limit -> {
+      cursor;
       feed;
       limit;
-      cursor;
     })
+  |> 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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module SearchPosts = 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;
-  since : string option;
+  tag : string list option;
   until : string option;
-  mentions : string option;
-  author : string option;
-  lang : string option;
-  domain : string option;
   url : string option;
-  tag : string list option;
-  limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun q sort since until mentions author lang domain url tag limit cursor -> {
+    (fun author cursor domain lang limit mentions q since sort tag until url -> {
+      author;
+      cursor;
+      domain;
+      lang;
+      limit;
+      mentions;
       q;
+      since;
       sort;
-      since;
+      tag;
       until;
-      mentions;
-      author;
-      lang;
-      domain;
       url;
-      tag;
-      limit;
-      cursor;
     })
+  |> 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 "since" Jsont.string
-       ~enc:(fun r -> r.since)
+  |> 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 "mentions" Jsont.string
-       ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.opt_mem "author" Jsont.string
-       ~enc:(fun r -> r.author)
-  |> Jsont.Object.opt_mem "lang" Jsont.string
-       ~enc:(fun r -> r.lang)
-  |> Jsont.Object.opt_mem "domain" Jsont.string
-       ~enc:(fun r -> r.domain)
   |> Jsont.Object.opt_mem "url" Jsont.string
        ~enc:(fun r -> r.url)
-  |> Jsont.Object.opt_mem "tag" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.tag)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       module GetAuthorFeed = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
   filter : string option;
   include_pins : bool option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor filter include_pins -> {
+    (fun actor cursor filter include_pins limit -> {
       actor;
-      limit;
       cursor;
       filter;
       include_pins;
+      limit;
     })
   |> Jsont.Object.mem "actor" Jsont.string
        ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
   |> 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 = {
···
   |> Jsont.Object.finish
 
 type output = {
-  view : Jsont.json;
   is_online : bool;
   is_valid : bool;
+  view : Jsont.json;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ view is_online is_valid -> { view; is_online; is_valid })
+    (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 "view" Jsont.json ~enc:(fun r -> r.view)
   |> 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 GetSuggestedFeeds = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
+    (fun cursor limit -> {
+      cursor;
       limit;
-      cursor;
     })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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 = {
···
       module GetActorFeeds = struct
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun actor limit cursor -> {
+    (fun actor cursor limit -> {
       actor;
-      limit;
       cursor;
+      limit;
     })
   |> Jsont.Object.mem "actor" Jsont.string
        ~enc:(fun r -> r.actor)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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 = {
···
       module GetTimeline = struct
 type params = {
   algorithm : string option;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun algorithm limit cursor -> {
+    (fun algorithm cursor limit -> {
       algorithm;
-      limit;
       cursor;
+      limit;
     })
   |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module CreateBookmark = struct
 type input = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ uri cid -> { uri; cid })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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 bookmark = {
+type bookmark_view = {
+  created_at : string option;
+  item : Jsont.json;
   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")
+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_view = {
+type bookmark = {
   subject : Com.Atproto.Repo.StrongRef.main;
-  created_at : string option;
-  item : Jsont.json;
 }
 
-let bookmark_view_jsont =
-  Jsont.Object.map ~kind:"Bookmark_view"
-    (fun _typ subject created_at item -> { subject; created_at; item })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.bookmark.defs#bookmarkView" ~enc:(fun _ -> "app.bsky.bookmark.defs#bookmarkView")
+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.opt_mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "item" Jsont.json ~enc:(fun r -> r.item)
   |> Jsont.Object.finish
 
       end
       module GetBookmarks = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
-      limit;
+    (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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
-  cursor : string option;
   bookmarks : Defs.bookmark_view list;
+  cursor : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor bookmarks -> { cursor; bookmarks })
+    (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.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> 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.finish
 
       end
···
     module Unspecced = struct
       module GetSuggestedUsersSkeleton = struct
 type params = {
-  viewer : string option;
   category : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer category limit -> {
-      viewer;
+    (fun category limit viewer -> {
       category;
       limit;
+      viewer;
     })
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.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 = {
···
       end
       module GetPopularFeedGenerators = struct
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
   query : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor query -> {
-      limit;
+    (fun cursor limit query -> {
       cursor;
+      limit;
       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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.opt_mem "query" Jsont.string
        ~enc:(fun r -> r.query)
   |> Jsont.Object.finish
···
       end
       module GetSuggestedStarterPacksSkeleton = struct
 type params = {
-  viewer : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit -> {
-      viewer;
+    (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.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetSuggestedFeedsSkeleton = struct
 type params = {
-  viewer : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit -> {
-      viewer;
+    (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.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetOnboardingSuggestedStarterPacksSkeleton = struct
 type params = {
-  viewer : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit -> {
+    (fun limit viewer -> {
+      limit;
       viewer;
-      limit;
     })
+  |> 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.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
···
 
       end
       module Defs = struct
-type skeleton_search_post = {
-  uri : string;
-}
-
-let skeleton_search_post_jsont =
-  Jsont.Object.map ~kind:"Skeleton_search_post"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchPost" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchPost")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
-type skeleton_search_actor = {
-  did : string;
-}
-
-let skeleton_search_actor_jsont =
-  Jsont.Object.map ~kind:"Skeleton_search_actor"
-    (fun _typ did -> { did })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchActor" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchActor")
-  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
-  |> Jsont.Object.finish
-
-type skeleton_search_starter_pack = {
-  uri : string;
-}
-
-let skeleton_search_starter_pack_jsont =
-  Jsont.Object.map ~kind:"Skeleton_search_starter_pack"
-    (fun _typ uri -> { uri })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchStarterPack" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchStarterPack")
-  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
-  |> Jsont.Object.finish
-
 type trending_topic = {
-  topic : string;
-  display_name : string option;
   description : string option;
+  display_name : string option;
   link : string;
+  topic : string;
 }
 
 let trending_topic_jsont =
   Jsont.Object.map ~kind:"Trending_topic"
-    (fun _typ topic display_name description link -> { topic; display_name; description; link })
+    (fun _typ description display_name link topic -> { description; display_name; link; topic })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#trendingTopic" ~enc:(fun _ -> "app.bsky.unspecced.defs#trendingTopic")
-  |> Jsont.Object.mem "topic" Jsont.string ~enc:(fun r -> r.topic)
+  |> 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 "description" Jsont.string ~enc:(fun r -> r.description)
   |> Jsont.Object.mem "link" Jsont.string ~enc:(fun r -> r.link)
-  |> Jsont.Object.finish
-
-type skeleton_trend = {
-  topic : string;
-  display_name : string;
-  link : string;
-  started_at : string;
-  post_count : int;
-  status : string option;
-  category : string option;
-  dids : string list;
-}
-
-let skeleton_trend_jsont =
-  Jsont.Object.map ~kind:"Skeleton_trend"
-    (fun _typ topic display_name link started_at post_count status category dids -> { topic; display_name; link; started_at; post_count; status; category; dids })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonTrend" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonTrend")
   |> Jsont.Object.mem "topic" Jsont.string ~enc:(fun r -> r.topic)
-  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
-  |> Jsont.Object.mem "link" Jsont.string ~enc:(fun r -> r.link)
-  |> Jsont.Object.mem "startedAt" Jsont.string ~enc:(fun r -> r.started_at)
-  |> Jsont.Object.mem "postCount" Jsont.int ~enc:(fun r -> r.post_count)
-  |> Jsont.Object.opt_mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.opt_mem "category" Jsont.string ~enc:(fun r -> r.category)
-  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string) ~enc:(fun r -> r.dids)
   |> Jsont.Object.finish
 
 type trend_view = {
-  topic : string;
+  actors : Jsont.json list;
+  category : string option;
   display_name : string;
   link : string;
-  started_at : string;
   post_count : int;
+  started_at : string;
   status : string option;
-  category : string option;
-  actors : Jsont.json list;
+  topic : string;
 }
 
 let trend_view_jsont =
   Jsont.Object.map ~kind:"Trend_view"
-    (fun _typ topic display_name link started_at post_count status category actors -> { topic; display_name; link; started_at; post_count; status; category; actors })
+    (fun _typ actors category display_name link post_count started_at status topic -> { actors; category; display_name; link; post_count; started_at; status; topic })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#trendView" ~enc:(fun _ -> "app.bsky.unspecced.defs#trendView")
-  |> Jsont.Object.mem "topic" Jsont.string ~enc:(fun r -> r.topic)
+  |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
+  |> Jsont.Object.opt_mem "category" Jsont.string ~enc:(fun r -> r.category)
   |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
   |> Jsont.Object.mem "link" Jsont.string ~enc:(fun r -> r.link)
+  |> Jsont.Object.mem "postCount" Jsont.int ~enc:(fun r -> r.post_count)
   |> Jsont.Object.mem "startedAt" Jsont.string ~enc:(fun r -> r.started_at)
-  |> Jsont.Object.mem "postCount" Jsont.int ~enc:(fun r -> r.post_count)
   |> Jsont.Object.opt_mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.opt_mem "category" Jsont.string ~enc:(fun r -> r.category)
-  |> Jsont.Object.mem "actors" (Jsont.list Jsont.json) ~enc:(fun r -> r.actors)
+  |> Jsont.Object.mem "topic" Jsont.string ~enc:(fun r -> r.topic)
   |> Jsont.Object.finish
 
 type thread_item_post = {
-  post : Jsont.json;
+  hidden_by_threadgate : bool;
   more_parents : bool;
   more_replies : int;
-  op_thread : bool;
-  hidden_by_threadgate : bool;
   muted_by_viewer : bool;
+  op_thread : bool;
+  post : Jsont.json;
 }
 
 let thread_item_post_jsont =
   Jsont.Object.map ~kind:"Thread_item_post"
-    (fun _typ post more_parents more_replies op_thread hidden_by_threadgate muted_by_viewer -> { post; more_parents; more_replies; op_thread; hidden_by_threadgate; muted_by_viewer })
+    (fun _typ hidden_by_threadgate more_parents more_replies muted_by_viewer op_thread post -> { hidden_by_threadgate; more_parents; more_replies; muted_by_viewer; op_thread; post })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#threadItemPost" ~enc:(fun _ -> "app.bsky.unspecced.defs#threadItemPost")
-  |> Jsont.Object.mem "post" Jsont.json ~enc:(fun r -> r.post)
+  |> Jsont.Object.mem "hiddenByThreadgate" Jsont.bool ~enc:(fun r -> r.hidden_by_threadgate)
   |> Jsont.Object.mem "moreParents" Jsont.bool ~enc:(fun r -> r.more_parents)
   |> Jsont.Object.mem "moreReplies" Jsont.int ~enc:(fun r -> r.more_replies)
+  |> Jsont.Object.mem "mutedByViewer" Jsont.bool ~enc:(fun r -> r.muted_by_viewer)
   |> Jsont.Object.mem "opThread" Jsont.bool ~enc:(fun r -> r.op_thread)
-  |> Jsont.Object.mem "hiddenByThreadgate" Jsont.bool ~enc:(fun r -> r.hidden_by_threadgate)
-  |> Jsont.Object.mem "mutedByViewer" Jsont.bool ~enc:(fun r -> r.muted_by_viewer)
+  |> Jsont.Object.mem "post" Jsont.json ~enc:(fun r -> r.post)
   |> Jsont.Object.finish
 
+type thread_item_not_found = unit
+
+let thread_item_not_found_jsont = Jsont.ignore
+
 type thread_item_no_unauthenticated = unit
 
 let thread_item_no_unauthenticated_jsont = Jsont.ignore
-
-type thread_item_not_found = unit
-
-let thread_item_not_found_jsont = Jsont.ignore
 
 type thread_item_blocked = {
   author : Jsont.json;
···
   |> Jsont.Object.mem "author" Jsont.json ~enc:(fun r -> r.author)
   |> Jsont.Object.finish
 
+type skeleton_trend = {
+  category : string option;
+  dids : string list;
+  display_name : string;
+  link : string;
+  post_count : int;
+  started_at : string;
+  status : string option;
+  topic : string;
+}
+
+let skeleton_trend_jsont =
+  Jsont.Object.map ~kind:"Skeleton_trend"
+    (fun _typ category dids display_name link post_count started_at status topic -> { category; dids; display_name; link; post_count; started_at; status; topic })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonTrend" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonTrend")
+  |> Jsont.Object.opt_mem "category" Jsont.string ~enc:(fun r -> r.category)
+  |> Jsont.Object.mem "dids" (Jsont.list Jsont.string) ~enc:(fun r -> r.dids)
+  |> Jsont.Object.mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+  |> Jsont.Object.mem "link" Jsont.string ~enc:(fun r -> r.link)
+  |> Jsont.Object.mem "postCount" Jsont.int ~enc:(fun r -> r.post_count)
+  |> Jsont.Object.mem "startedAt" Jsont.string ~enc:(fun r -> r.started_at)
+  |> Jsont.Object.opt_mem "status" Jsont.string ~enc:(fun r -> r.status)
+  |> Jsont.Object.mem "topic" Jsont.string ~enc:(fun r -> r.topic)
+  |> Jsont.Object.finish
+
+type skeleton_search_starter_pack = {
+  uri : string;
+}
+
+let skeleton_search_starter_pack_jsont =
+  Jsont.Object.map ~kind:"Skeleton_search_starter_pack"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchStarterPack" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchStarterPack")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type skeleton_search_post = {
+  uri : string;
+}
+
+let skeleton_search_post_jsont =
+  Jsont.Object.map ~kind:"Skeleton_search_post"
+    (fun _typ uri -> { uri })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchPost" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchPost")
+  |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
+  |> Jsont.Object.finish
+
+type skeleton_search_actor = {
+  did : string;
+}
+
+let skeleton_search_actor_jsont =
+  Jsont.Object.map ~kind:"Skeleton_search_actor"
+    (fun _typ did -> { did })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#skeletonSearchActor" ~enc:(fun _ -> "app.bsky.unspecced.defs#skeletonSearchActor")
+  |> Jsont.Object.mem "did" Jsont.string ~enc:(fun r -> r.did)
+  |> Jsont.Object.finish
+
 type age_assurance_state = {
   last_initiated_at : string option;
   status : string;
···
   |> Jsont.Object.finish
 
 type age_assurance_event = {
+  attempt_id : string;
+  complete_ip : string option;
+  complete_ua : string option;
   created_at : string;
-  status : string;
-  attempt_id : string;
   email : string option;
   init_ip : string option;
   init_ua : string option;
-  complete_ip : string option;
-  complete_ua : string option;
+  status : string;
 }
 
 let age_assurance_event_jsont =
   Jsont.Object.map ~kind:"Age_assurance_event"
-    (fun _typ created_at status attempt_id email init_ip init_ua complete_ip complete_ua -> { created_at; status; attempt_id; email; init_ip; init_ua; complete_ip; complete_ua })
+    (fun _typ attempt_id complete_ip complete_ua created_at email init_ip init_ua status -> { attempt_id; complete_ip; complete_ua; created_at; email; init_ip; init_ua; status })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.defs#ageAssuranceEvent" ~enc:(fun _ -> "app.bsky.unspecced.defs#ageAssuranceEvent")
+  |> 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 "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.status)
-  |> Jsont.Object.mem "attemptId" Jsont.string ~enc:(fun r -> r.attempt_id)
   |> 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 "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 "status" Jsont.string ~enc:(fun r -> r.status)
   |> Jsont.Object.finish
 
       end
       module GetTaggedSuggestions = struct
 type suggestion = {
-  tag : string;
-  subject_type : string;
   subject : string;
+  subject_type : string;
+  tag : string;
 }
 
 let suggestion_jsont =
   Jsont.Object.map ~kind:"Suggestion"
-    (fun _typ tag subject_type subject -> { tag; subject_type; subject })
+    (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 "tag" Jsont.string ~enc:(fun r -> r.tag)
+  |> 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 "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> Jsont.Object.mem "tag" Jsont.string ~enc:(fun r -> r.tag)
   |> Jsont.Object.finish
 
 type params = unit
···
       end
       module SearchPostsSkeleton = 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;
-  since : string option;
+  tag : string list option;
   until : string option;
-  mentions : string option;
-  author : string option;
-  lang : string option;
-  domain : string option;
   url : string option;
-  tag : string list option;
   viewer : string option;
-  limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun q sort since until mentions author lang domain url tag viewer limit cursor -> {
+    (fun author cursor domain lang limit mentions q since sort tag until url viewer -> {
+      author;
+      cursor;
+      domain;
+      lang;
+      limit;
+      mentions;
       q;
+      since;
       sort;
-      since;
+      tag;
       until;
-      mentions;
-      author;
-      lang;
-      domain;
       url;
-      tag;
       viewer;
-      limit;
-      cursor;
     })
+  |> 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 "since" Jsont.string
-       ~enc:(fun r -> r.since)
+  |> 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 "mentions" Jsont.string
-       ~enc:(fun r -> r.mentions)
-  |> Jsont.Object.opt_mem "author" Jsont.string
-       ~enc:(fun r -> r.author)
-  |> Jsont.Object.opt_mem "lang" Jsont.string
-       ~enc:(fun r -> r.lang)
-  |> Jsont.Object.opt_mem "domain" Jsont.string
-       ~enc:(fun r -> r.domain)
   |> Jsont.Object.opt_mem "url" Jsont.string
        ~enc:(fun r -> r.url)
-  |> Jsont.Object.opt_mem "tag" (Jsont.list Jsont.string)
-       ~enc:(fun r -> r.tag)
   |> Jsont.Object.opt_mem "viewer" Jsont.string
        ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetPostThreadV2 = struct
 type thread_item = {
+  depth : int;
   uri : string;
-  depth : int;
   value : Jsont.json;
 }
 
 let thread_item_jsont =
   Jsont.Object.map ~kind:"Thread_item"
-    (fun _typ uri depth value -> { uri; depth; value })
+    (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 "uri" Jsont.string ~enc:(fun r -> r.uri)
   |> 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 = {
-  anchor : string;
   above : bool option;
+  anchor : string;
   below : int option;
   branching_factor : int option;
   sort : string option;
···
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun anchor above below branching_factor sort -> {
+    (fun above anchor below branching_factor sort -> {
+      above;
       anchor;
-      above;
       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 "above" Jsont.bool
-       ~enc:(fun r -> r.above)
   |> Jsont.Object.opt_mem "below" Jsont.int
        ~enc:(fun r -> r.below)
   |> Jsont.Object.opt_mem "branchingFactor" Jsont.int
···
   |> Jsont.Object.finish
 
 type output = {
+  has_other_replies : bool;
   thread : thread_item list;
   threadgate : Jsont.json option;
-  has_other_replies : bool;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ thread threadgate has_other_replies -> { thread; threadgate; has_other_replies })
+    (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.mem "hasOtherReplies" Jsont.bool ~enc:(fun r -> r.has_other_replies)
   |> Jsont.Object.finish
 
       end
       module GetTrendingTopics = struct
 type params = {
-  viewer : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit -> {
+    (fun limit viewer -> {
+      limit;
       viewer;
-      limit;
     })
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.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 = {
-  topics : Defs.trending_topic list;
   suggested : Defs.trending_topic list;
+  topics : Defs.trending_topic list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ topics suggested -> { topics; suggested })
+    (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.mem "suggested" (Jsont.list Defs.trending_topic_jsont) ~enc:(fun r -> r.suggested)
   |> Jsont.Object.finish
 
       end
       module GetTrendsSkeleton = struct
 type params = {
-  viewer : string option;
   limit : int option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit -> {
-      viewer;
+    (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.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module GetPostThreadOtherV2 = struct
 type thread_item = {
-  uri : string;
   depth : int;
+  uri : string;
   value : Defs.thread_item_post;
 }
 
 let thread_item_jsont =
   Jsont.Object.map ~kind:"Thread_item"
-    (fun _typ uri depth value -> { uri; depth; value })
+    (fun _typ depth uri value -> { depth; uri; value })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"app.bsky.unspecced.getPostThreadOtherV2#threadItem" ~enc:(fun _ -> "app.bsky.unspecced.getPostThreadOtherV2#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 "depth" Jsont.int ~enc:(fun r -> r.depth)
   |> Jsont.Object.mem "value" Defs.thread_item_post_jsont ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
···
       end
       module InitAgeAssurance = struct
 type input = {
+  country_code : string;
   email : string;
   language : string;
-  country_code : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ email language country_code -> { email; language; country_code })
+    (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.mem "countryCode" Jsont.string ~enc:(fun r -> r.country_code)
   |> Jsont.Object.finish
 
 type output = Defs.age_assurance_state
···
       end
       module SearchStarterPacksSkeleton = struct
 type params = {
+  cursor : string option;
+  limit : int option;
   q : string;
   viewer : string option;
-  limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun q viewer limit cursor -> {
+    (fun cursor limit q viewer -> {
+      cursor;
+      limit;
       q;
       viewer;
-      limit;
-      cursor;
     })
+  |> 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 "viewer" Jsont.string
        ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module SearchActorsSkeleton = struct
 type params = {
+  cursor : string option;
+  limit : int option;
   q : string;
-  viewer : string option;
   typeahead : bool option;
-  limit : int option;
-  cursor : string option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun q viewer typeahead limit cursor -> {
+    (fun cursor limit q typeahead viewer -> {
+      cursor;
+      limit;
       q;
-      viewer;
       typeahead;
-      limit;
-      cursor;
+      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 "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
   |> Jsont.Object.opt_mem "typeahead" Jsont.bool
        ~enc:(fun r -> r.typeahead)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> 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;
-  actors : Defs.skeleton_search_actor list;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor hits_total actors -> { cursor; hits_total; actors })
+    (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 "actors" (Jsont.list Defs.skeleton_search_actor_jsont) ~enc:(fun r -> r.actors)
   |> Jsont.Object.finish
 
       end
···
       end
       module GetSuggestionsSkeleton = struct
 type params = {
-  viewer : string option;
-  limit : int option;
   cursor : string option;
+  limit : int option;
   relative_to_did : string option;
+  viewer : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun viewer limit cursor relative_to_did -> {
-      viewer;
+    (fun cursor limit relative_to_did viewer -> {
+      cursor;
       limit;
-      cursor;
       relative_to_did;
+      viewer;
     })
-  |> Jsont.Object.opt_mem "viewer" Jsont.string
-       ~enc:(fun r -> r.viewer)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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.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;
-  actors : Defs.skeleton_search_actor list;
+  rec_id : int option;
   relative_to_did : string option;
-  rec_id : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ cursor actors relative_to_did rec_id -> { cursor; actors; relative_to_did; rec_id })
+    (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.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
   |> 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)
-  |> Jsont.Object.opt_mem "recId" Jsont.int ~enc:(fun r -> r.rec_id)
   |> Jsont.Object.finish
 
       end

lexicons/bsky/atp_lexicon_bsky.mli

···
   module Atproto : sig
     module Label : sig
       module Defs : sig
-(** Metadata tag on an atproto resource (eg, repo or record). *)
-
-type label = {
-  ver : int option;  (** The AT Protocol version of the label object. *)
-  src : string;  (** DID of the actor who created this label. *)
-  uri : string;  (** AT URI of the record, repository (account), or other resource that this label applies to. *)
-  cid : string option;  (** Optionally, CID specifying the specific version of 'uri' resource this label applies to. *)
-  val_ : string;  (** The short string name of the value or type of this label. *)
-  neg : bool option;  (** If true, this is a negation label, overwriting a previous label. *)
-  cts : string;  (** Timestamp when this label was created. *)
-  exp : string option;  (** Timestamp at which this label expires (no longer applies). *)
-  sig_ : string option;  (** Signature of dag-cbor encoded label. *)
-}
-
-(** Jsont codec for {!type:label}. *)
-val label_jsont : label Jsont.t
-
 (** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. *)
 
 type self_label = {
···
 (** Strings which describe the label in the UI, localized into a specific language. *)
 
 type label_value_definition_strings = {
+  description : string;  (** A longer description of what the label means and why it might be applied. *)
   lang : string;  (** The code of the language these strings are written in. *)
   name : string;  (** A short human-readable name for the label. *)
-  description : string;  (** A longer description of what the label means and why it might be applied. *)
 }
 
 (** Jsont codec for {!type:label_value_definition_strings}. *)
···
 type label_value = string
 val label_value_jsont : label_value Jsont.t
 
+(** Metadata tag on an atproto resource (eg, repo or record). *)
+
+type label = {
+  cid : string option;  (** Optionally, CID specifying the specific version of 'uri' resource this label applies to. *)
+  cts : string;  (** Timestamp when this label was created. *)
+  exp : string option;  (** Timestamp at which this label expires (no longer applies). *)
+  neg : bool option;  (** If true, this is a negation label, overwriting a previous label. *)
+  sig_ : string option;  (** Signature of dag-cbor encoded label. *)
+  src : string;  (** DID of the actor who created this label. *)
+  uri : string;  (** AT URI of the record, repository (account), or other resource that this label applies to. *)
+  val_ : string;  (** The short string name of the value or type of this label. *)
+  ver : int option;  (** The AT Protocol version of the label object. *)
+}
+
+(** Jsont codec for {!type:label}. *)
+val label_jsont : label Jsont.t
+
 (** Metadata tags on an atproto record, published by the author within the record. *)
 
 type self_labels = {
···
 (** Declares a label value and its expected interpretations and behaviors. *)
 
 type label_value_definition = {
-  identifier : string;  (** The value of the label being defined. Must only include lowercase ascii and the '-' character (\[a-z-\]+). *)
-  severity : string;  (** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. *)
+  adult_only : bool option;  (** Does the user need to have adult content enabled in order to configure this label? *)
   blurs : string;  (** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. *)
   default_setting : string option;  (** The default setting for this label. *)
-  adult_only : bool option;  (** Does the user need to have adult content enabled in order to configure this label? *)
+  identifier : string;  (** The value of the label being defined. Must only include lowercase ascii and the '-' character (\[a-z-\]+). *)
   locales : label_value_definition_strings list;
+  severity : string;  (** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. *)
 }
 
 (** Jsont codec for {!type:label_value_definition}. *)
···
       module StrongRef : sig
 
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
     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
···
 type reason_spam = string
 val reason_spam_jsont : reason_spam 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
-
-(** 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
-
 (** Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`. *)
 
 type reason_sexual = string
···
 
 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
 
-(** Tag describing a type of subject that might be reported. *)
-
-type subject_type = string
-val subject_type_jsont : subject_type Jsont.t
-
       end
     end
   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'). *)
+
+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 = {
···
 (** Jsont codec for {!type:link}. *)
 val link_jsont : link Jsont.t
 
-(** 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
-
 (** 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;
-  byte_end : int;
 }
 
 (** Jsont codec for {!type:byte_slice}. *)
···
 (** Annotation of a sub-string within rich text. *)
 
 type main = {
-  index : byte_slice;
   features : Jsont.json list;
+  index : byte_slice;
 }
 
 (** Jsont codec for {!type:main}. *)
···
     end
     module Ageassurance : sig
       module Defs : sig
-(** The access level granted based on Age Assurance data we've processed. *)
-
-type access = string
-val access_jsont : access Jsont.t
-
 (** The status of the Age Assurance process. *)
 
 type status = string
···
 (** Jsont codec for {!type:state_metadata}. *)
 val state_metadata_jsont : state_metadata 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. *)
-  region_code : string option;  (** The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country. *)
-  min_access_age : int;  (** The minimum age (as a whole integer) required to use Bluesky in this region. *)
-  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
-
 (** Object used to store Age Assurance data in stash. *)
 
 type event = {
-  created_at : string;  (** The date and time of this write operation. *)
-  attempt_id : string;  (** The unique identifier for this instance of the Age Assurance flow, in UUID format. *)
-  status : string;  (** The status of the Age Assurance process. *)
   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. *)
-  region_code : string option;  (** The ISO 3166-2 region 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. *)
-  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. *)
+  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;
-  access : access;
 }
 
 (** 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 = {
-  regions : config_region list;  (** The per-region Age Assurance configuration. *)
-}
-
-(** Jsont codec for {!type:config}. *)
-val config_jsont : config Jsont.t
-
-(** Age Assurance rule that applies by default. *)
-
-type config_region_rule_default = {
+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_default}. *)
-val config_region_rule_default_jsont : config_region_rule_default Jsont.t
+(** 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 = {
-  age : int;  (** The age threshold as a whole integer. *)
   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 declared themselves under a certain age. *)
+(** Age Assurance rule that applies if the user has been assured to be under a certain age. *)
 
-type config_region_rule_if_declared_under_age = {
+type config_region_rule_if_assured_under_age = {
+  access : access;
   age : int;  (** The age threshold as a whole integer. *)
-  access : access;
 }
 
-(** 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: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 = {
-  age : int;  (** The age threshold as a whole integer. *)
   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 user has been assured to be under a certain age. *)
+(** Age Assurance rule that applies if the account is older than a certain date. *)
 
-type config_region_rule_if_assured_under_age = {
-  age : int;  (** The age threshold as a whole integer. *)
+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_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: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 = {
-  date : string;  (** The date threshold as a datetime string. *)
   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 if the account is older than a certain date. *)
+(** Age Assurance rule that applies by default. *)
 
-type config_region_rule_if_account_older_than = {
-  date : string;  (** The date threshold as a datetime string. *)
+type config_region_rule_default = {
   access : access;
 }
 
-(** 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: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
···
 
 
 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. *)
-  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
   region_code : string option;  (** An optional ISO 3166-2 code of the user's region or state within the country. *)
 }
 
···
 
 
 type output = {
-  state : Defs.state;
   metadata : Defs.state_metadata;
+  state : Defs.state;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 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. *)
-  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. *)
 }
 
 (** Jsont codec for {!type:labeler_policies}. *)
 val labeler_policies_jsont : labeler_policies Jsont.t
 
 
-type labeler_view = {
-  uri : string;
+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;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
 }
 
-(** Jsont codec for {!type:labeler_view}. *)
-val labeler_view_jsont : labeler_view Jsont.t
+(** Jsont codec for {!type:labeler_view_detailed}. *)
+val labeler_view_detailed_jsont : labeler_view_detailed Jsont.t
 
 
-type labeler_view_detailed = {
-  uri : string;
+type labeler_view = {
   cid : string;
   creator : Jsont.json;
-  policies : Jsont.json;
-  like_count : int option;
-  viewer : Jsont.json option;
   indexed_at : string;
   labels : Com.Atproto.Label.Defs.label list option;
-  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_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
-  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. *)
+  like_count : int option;
+  uri : string;
+  viewer : Jsont.json option;
 }
 
-(** Jsont codec for {!type:labeler_view_detailed}. *)
-val labeler_view_detailed_jsont : labeler_view_detailed Jsont.t
+(** 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 = {
-  policies : Jsont.json;
-  labels : Com.Atproto.Label.Defs.self_labels option;
   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_types : Com.Atproto.Moderation.Defs.subject_type list option;  (** The set of subject types (account, record, etc) this service accepts reports on. *)
   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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  dids : string list;
   detailed : bool option;
+  dids : string list;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 type output = {
   can_upload : bool;
-  remaining_daily_videos : int option;
-  remaining_daily_bytes : int option;
-  message : string option;
   error : string option;
+  message : string option;
+  remaining_daily_bytes : int option;
+  remaining_daily_videos : int option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
       module Defs : sig
 
 type job_status = {
-  job_id : string;
+  blob : Atp.Blob_ref.t option;
   did : string;
-  state : string;  (** The state of the video processing job. All values not listed as a known value indicate that the job is in process. *)
-  progress : int option;  (** Progress within the current processing state. *)
-  blob : Atp.Blob_ref.t option;
   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}. *)
···
     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_ = {
-  uri : string;
-  title : string;
   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 = {
-  uri : string;
-  title : string;
-  description : string;
-  thumb : string option;
+type view = {
+  external_ : Jsont.json;
 }
 
-(** Jsont codec for {!type:view_external}. *)
-val view_external_jsont : view_external Jsont.t
+(** 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). *)
 
···
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-
-type view = {
-  external_ : Jsont.json;
-}
-
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view 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 = {
-  width : int;
   height : int;
+  width : int;
 }
 
 (** Jsont codec for {!type:aspect_ratio}. *)
···
       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 = {
-  image : Atp.Blob_ref.t;
   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_image = {
-  thumb : string;  (** Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View. *)
-  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. *)
-  alt : string;  (** Alt text description of the image, for accessibility. *)
-  aspect_ratio : Jsont.json option;
+type view = {
+  images : Jsont.json list;
 }
 
-(** Jsont codec for {!type:view_image}. *)
-val view_image_jsont : view_image Jsont.t
+(** Jsont codec for {!type:view}. *)
+val view_jsont : view Jsont.t
 
 
 type main = {
···
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
+      end
+      module Video : sig
 
 type view = {
-  images : Jsont.json list;
+  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
 
-      end
-      module Video : sig
 
 type caption = {
-  lang : string;
   file : Atp.Blob_ref.t;
+  lang : string;
 }
 
 (** Jsont codec for {!type:caption}. *)
 val caption_jsont : caption Jsont.t
 
 
-type view = {
-  cid : string;
-  playlist : string;
-  thumbnail : string option;
-  alt : string option;
-  aspect_ratio : Jsont.json option;
-}
-
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
-
-
 type main = {
-  video : Atp.Blob_ref.t;  (** The mp4 video file. May be up to 100mb, formerly limited to 50mb. *)
-  captions : Jsont.json list option;
   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}. *)
···
       end
       module RecordWithMedia : sig
 
-type main = {
-  record : Jsont.json;
-  media : Jsont.json;
-}
-
-(** Jsont codec for {!type:main}. *)
-val main_jsont : main Jsont.t
-
-
 type view = {
-  record : Jsont.json;
   media : Jsont.json;
+  record : Jsont.json;
 }
 
 (** Jsont codec for {!type:view}. *)
 val view_jsont : view Jsont.t
 
-      end
-      module Record : sig
 
 type main = {
-  record : Com.Atproto.Repo.StrongRef.main;
+  media : Jsont.json;
+  record : Jsont.json;
 }
 
 (** Jsont codec for {!type:main}. *)
 val main_jsont : main Jsont.t
 
-
-type view = {
-  record : Jsont.json;
-}
-
-(** Jsont codec for {!type:view}. *)
-val view_jsont : view Jsont.t
-
+      end
+      module Record : sig
 
 type view_record = {
-  uri : string;
-  cid : string;
   author : Jsont.json;
-  value : Jsont.json;  (** The record data itself. *)
+  cid : string;
+  embeds : Jsont.json list option;
+  indexed_at : string;
   labels : Com.Atproto.Label.Defs.label list option;
-  reply_count : int option;
-  repost_count : int option;
   like_count : int option;
   quote_count : int option;
-  embeds : Jsont.json list option;
-  indexed_at : string;
+  reply_count : int option;
+  repost_count : int option;
+  uri : string;
+  value : Jsont.json;  (** The record data itself. *)
 }
 
 (** Jsont codec for {!type:view_record}. *)
···
 
 
 type view_not_found = {
-  uri : string;
   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;
-  blocked : bool;
-  author : Jsont.json;
 }
 
 (** Jsont codec for {!type:view_blocked}. *)
 val view_blocked_jsont : view_blocked Jsont.t
 
 
-type view_detached = {
-  uri : string;
-  detached : bool;
+type view = {
+  record : Jsont.json;
 }
 
-(** Jsont codec for {!type:view_detached}. *)
-val view_detached_jsont : view_detached Jsont.t
+(** 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
···
 
 
 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;
-  platform : string;
-  app_id : string;
-  age_restricted : bool option;  (** Set to true when the actor is age restricted *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
       module ListNotifications : sig
 
 type notification = {
-  uri : string;
+  author : Jsont.json;
   cid : string;
-  author : Jsont.json;
+  indexed_at : string;
+  is_read : bool;
+  labels : Com.Atproto.Label.Defs.label list option;
   reason : string;  (** The reason why this notification was delivered - e.g. your post was liked, or you received a new follower. *)
   reason_subject : string option;
   record : Jsont.json;
-  is_read : bool;
-  indexed_at : string;
-  labels : Com.Atproto.Label.Defs.label list option;
+  uri : string;
 }
 
 (** Jsont codec for {!type:notification}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  reasons : string list option;  (** Notification reasons to include in response. *)
+  cursor : string option;
   limit : int option;
   priority : bool option;
-  cursor : string option;
+  reasons : string list option;  (** Notification reasons to include in response. *)
   seen_at : string option;
 }
 
···
 
 
 type input = {
+  app_id : string;
+  platform : string;
   service_did : string;
   token : string;
-  platform : string;
-  app_id : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 val record_deleted_jsont : record_deleted Jsont.t
 
 
-type chat_preference = {
-  include_ : string;
+type preference = {
+  list_ : bool;
   push : bool;
 }
 
-(** Jsont codec for {!type:chat_preference}. *)
-val chat_preference_jsont : chat_preference Jsont.t
+(** Jsont codec for {!type:preference}. *)
+val preference_jsont : preference Jsont.t
 
 
 type filterable_preference = {
···
 val filterable_preference_jsont : filterable_preference Jsont.t
 
 
-type preference = {
-  list_ : bool;
+type chat_preference = {
+  include_ : string;
   push : bool;
 }
 
-(** Jsont codec for {!type:preference}. *)
-val preference_jsont : preference Jsont.t
+(** Jsont codec for {!type:chat_preference}. *)
+val chat_preference_jsont : chat_preference Jsont.t
 
 
 type activity_subscription = {
···
 
 (** Jsont codec for {!type:activity_subscription}. *)
 val activity_subscription_jsont : activity_subscription Jsont.t
+
+(** Object used to store activity subscription data in stash. *)
+
+type subject_activity_subscription = {
+  activity_subscription : Jsont.json;
+  subject : string;
+}
+
+(** Jsont codec for {!type:subject_activity_subscription}. *)
+val subject_activity_subscription_jsont : subject_activity_subscription Jsont.t
 
 
 type preferences = {
···
 (** Jsont codec for {!type:preferences}. *)
 val preferences_jsont : preferences Jsont.t
 
-(** Object used to store activity subscription data in stash. *)
-
-type subject_activity_subscription = {
-  subject : string;
-  activity_subscription : Jsont.json;
-}
-
-(** Jsont codec for {!type:subject_activity_subscription}. *)
-val subject_activity_subscription_jsont : subject_activity_subscription Jsont.t
-
       end
       module Declaration : sig
 (** A declaration of the user's choices related to notifications that can be produced by them. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type input = {
-  subject : string;
   activity_subscription : Jsont.json;
+  subject : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
-  subject : string;
   activity_subscription : Jsont.json option;
+  subject : string;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 (** A declaration of a Bluesky account status. *)
 
 type main = {
-  status : string;  (** The status for the account. *)
-  embed : Jsont.json option;  (** An optional embed associated with the status. *)
-  duration_minutes : int option;  (** The duration of the status in minutes. Applications can choose to impose minimum and maximum limits. *)
   created_at : string;
+  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}. *)
···
 (** A declaration of a Bluesky account profile. *)
 
 type main = {
-  display_name : string option;
-  description : string option;  (** Free-form profile description text. *)
-  pronouns : string option;  (** Free-form pronouns text. *)
-  website : string option;
   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. *)
-  joined_via_starter_pack : Com.Atproto.Repo.StrongRef.main option;
   pinned_post : Com.Atproto.Repo.StrongRef.main option;
-  created_at : string option;
+  pronouns : string option;  (** Free-form pronouns text. *)
+  website : string option;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
       end
       module Defs : sig
-
-type profile_associated_chat = {
-  allow_incoming : string;
-}
-
-(** Jsont codec for {!type:profile_associated_chat}. *)
-val profile_associated_chat_jsont : profile_associated_chat Jsont.t
-
-
-type profile_associated_activity_subscription = {
-  allow_subscriptions : string;
-}
-
-(** Jsont codec for {!type:profile_associated_activity_subscription}. *)
-val profile_associated_activity_subscription_jsont : profile_associated_activity_subscription Jsont.t
-
 (** An individual verification for an associated subject. *)
 
 type verification_view = {
+  created_at : string;  (** Timestamp when the verification was created. *)
+  is_valid : bool;  (** True if the verification passes validation, otherwise false. *)
   issuer : string;  (** The user who issued this verification. *)
   uri : string;  (** The AT-URI of the verification record. *)
-  is_valid : bool;  (** True if the verification passes validation, otherwise false. *)
-  created_at : string;  (** Timestamp when the verification was created. *)
 }
 
 (** Jsont codec for {!type:verification_view}. *)
 val verification_view_jsont : verification_view Jsont.t
 
+(** Preferences for how verified accounts appear in the app. *)
 
-type preferences = Jsont.json list
-val preferences_jsont : preferences Jsont.t
-
-
-type adult_content_pref = {
-  enabled : bool;
+type verification_prefs = {
+  hide_badges : bool option;  (** Hide the blue check badges for verified accounts and trusted verifiers. *)
 }
 
-(** Jsont codec for {!type:adult_content_pref}. *)
-val adult_content_pref_jsont : adult_content_pref Jsont.t
+(** Jsont codec for {!type:verification_prefs}. *)
+val verification_prefs_jsont : verification_prefs Jsont.t
 
 
-type content_label_pref = {
-  labeler_did : string option;  (** Which labeler does this preference apply to? If undefined, applies globally. *)
-  label : string;
-  visibility : string;
+type thread_view_pref = {
+  sort : string option;  (** Sorting mode for threads. *)
 }
 
-(** Jsont codec for {!type:content_label_pref}. *)
-val content_label_pref_jsont : content_label_pref Jsont.t
+(** Jsont codec for {!type:thread_view_pref}. *)
+val thread_view_pref_jsont : thread_view_pref Jsont.t
 
 
-type saved_feed = {
-  id : string;
-  type_ : string;
-  value : string;
-  pinned : bool;
+type status_view = {
+  cid : string option;
+  embed : Jsont.json option;  (** An optional embed associated with the status. *)
+  expires_at : string option;  (** The date when this status will expire. The application might choose to no longer return the status after expiration. *)
+  is_active : bool option;  (** True if the status is not expired, false if it is expired. Only present if expiration was set. *)
+  is_disabled : bool option;  (** True if the user's go-live access has been disabled by a moderator, false otherwise. *)
+  record : Jsont.json;
+  status : string;  (** The status for the account. *)
+  uri : string option;
 }
 
-(** Jsont codec for {!type:saved_feed}. *)
-val saved_feed_jsont : saved_feed Jsont.t
+(** Jsont codec for {!type:status_view}. *)
+val status_view_jsont : status_view Jsont.t
 
 
 type saved_feeds_pref = {
···
 val saved_feeds_pref_jsont : saved_feeds_pref Jsont.t
 
 
-type personal_details_pref = {
-  birth_date : string option;  (** The birth date of account owner. *)
+type saved_feed = {
+  id : string;
+  pinned : bool;
+  type_ : string;
+  value : string;
 }
 
-(** Jsont codec for {!type:personal_details_pref}. *)
-val personal_details_pref_jsont : personal_details_pref Jsont.t
+(** Jsont codec for {!type:saved_feed}. *)
+val saved_feed_jsont : saved_feed Jsont.t
 
-(** Read-only preference containing value(s) inferred from the user's declared birthdate. Absence of this preference object in the response indicates that the user has not made a declaration. *)
 
-type declared_age_pref = {
-  is_over_age13 : bool option;  (** Indicates if the user has declared that they are over 13 years of age. *)
-  is_over_age16 : bool option;  (** Indicates if the user has declared that they are over 16 years of age. *)
-  is_over_age18 : bool option;  (** Indicates if the user has declared that they are over 18 years of age. *)
+type profile_associated_chat = {
+  allow_incoming : string;
 }
 
-(** Jsont codec for {!type:declared_age_pref}. *)
-val declared_age_pref_jsont : declared_age_pref Jsont.t
+(** Jsont codec for {!type:profile_associated_chat}. *)
+val profile_associated_chat_jsont : profile_associated_chat Jsont.t
 
 
-type feed_view_pref = {
-  feed : string;  (** The URI of the feed, or an identifier which describes the feed. *)
-  hide_replies : bool option;  (** Hide replies in the feed. *)
-  hide_replies_by_unfollowed : bool option;  (** Hide replies in the feed if they are not by followed users. *)
-  hide_replies_by_like_count : int option;  (** Hide replies in the feed if they do not have this number of likes. *)
-  hide_reposts : bool option;  (** Hide reposts in the feed. *)
-  hide_quote_posts : bool option;  (** Hide quote posts in the feed. *)
+type profile_associated_activity_subscription = {
+  allow_subscriptions : string;
 }
 
-(** Jsont codec for {!type:feed_view_pref}. *)
-val feed_view_pref_jsont : feed_view_pref Jsont.t
+(** Jsont codec for {!type:profile_associated_activity_subscription}. *)
+val profile_associated_activity_subscription_jsont : profile_associated_activity_subscription Jsont.t
 
 
-type thread_view_pref = {
-  sort : string option;  (** Sorting mode for threads. *)
+type preferences = Jsont.json list
+val preferences_jsont : preferences Jsont.t
+
+(** Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly. *)
+
+type post_interaction_settings_pref = {
+  postgate_embedding_rules : Jsont.json list option;  (** Matches postgate record. List of rules defining who can embed this users posts. If value is an empty array or is undefined, no particular rules apply and anyone can embed. *)
+  threadgate_allow_rules : Jsont.json list option;  (** Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply. *)
 }
 
-(** Jsont codec for {!type:thread_view_pref}. *)
-val thread_view_pref_jsont : thread_view_pref Jsont.t
+(** Jsont codec for {!type:post_interaction_settings_pref}. *)
+val post_interaction_settings_pref_jsont : post_interaction_settings_pref Jsont.t
 
 
-type interests_pref = {
-  tags : string list;  (** A list of tags which describe the account owner's interests gathered during onboarding. *)
+type personal_details_pref = {
+  birth_date : string option;  (** The birth date of account owner. *)
 }
 
-(** Jsont codec for {!type:interests_pref}. *)
-val interests_pref_jsont : interests_pref Jsont.t
+(** Jsont codec for {!type:personal_details_pref}. *)
+val personal_details_pref_jsont : personal_details_pref Jsont.t
 
+(** A new user experiences (NUX) storage object *)
 
-type muted_word_target = string
-val muted_word_target_jsont : muted_word_target Jsont.t
+type nux = {
+  completed : bool;
+  data : string option;  (** Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters. *)
+  expires_at : string option;  (** The date and time at which the NUX will expire and should be considered completed. *)
+  id : string;
+}
 
+(** Jsont codec for {!type:nux}. *)
+val nux_jsont : nux Jsont.t
 
-type hidden_posts_pref = {
-  items : string list;  (** A list of URIs of posts the account owner has hidden. *)
-}
 
-(** Jsont codec for {!type:hidden_posts_pref}. *)
-val hidden_posts_pref_jsont : hidden_posts_pref Jsont.t
+type muted_word_target = string
+val muted_word_target_jsont : muted_word_target Jsont.t
 
 
 type labeler_pref_item = {
···
 (** Jsont codec for {!type:labeler_pref_item}. *)
 val labeler_pref_item_jsont : labeler_pref_item Jsont.t
 
-(** If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress. *)
 
-type bsky_app_progress_guide = {
-  guide : string;
+type interests_pref = {
+  tags : string list;  (** A list of tags which describe the account owner's interests gathered during onboarding. *)
 }
 
-(** Jsont codec for {!type:bsky_app_progress_guide}. *)
-val bsky_app_progress_guide_jsont : bsky_app_progress_guide Jsont.t
+(** Jsont codec for {!type:interests_pref}. *)
+val interests_pref_jsont : interests_pref Jsont.t
 
-(** A new user experiences (NUX) storage object *)
 
-type nux = {
-  id : string;
-  completed : bool;
-  data : string option;  (** Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters. *)
-  expires_at : string option;  (** The date and time at which the NUX will expire and should be considered completed. *)
+type hidden_posts_pref = {
+  items : string list;  (** A list of URIs of posts the account owner has hidden. *)
 }
 
-(** Jsont codec for {!type:nux}. *)
-val nux_jsont : nux Jsont.t
+(** Jsont codec for {!type:hidden_posts_pref}. *)
+val hidden_posts_pref_jsont : hidden_posts_pref Jsont.t
 
-(** Preferences for how verified accounts appear in the app. *)
+
+type feed_view_pref = {
+  feed : string;  (** The URI of the feed, or an identifier which describes the feed. *)
+  hide_quote_posts : bool option;  (** Hide quote posts in the feed. *)
+  hide_replies : bool option;  (** Hide replies in the feed. *)
+  hide_replies_by_like_count : int option;  (** Hide replies in the feed if they do not have this number of likes. *)
+  hide_replies_by_unfollowed : bool option;  (** Hide replies in the feed if they are not by followed users. *)
+  hide_reposts : bool option;  (** Hide reposts in the feed. *)
+}
+
+(** Jsont codec for {!type:feed_view_pref}. *)
+val feed_view_pref_jsont : feed_view_pref Jsont.t
+
+(** Read-only preference containing value(s) inferred from the user's declared birthdate. Absence of this preference object in the response indicates that the user has not made a declaration. *)
 
-type verification_prefs = {
-  hide_badges : bool option;  (** Hide the blue check badges for verified accounts and trusted verifiers. *)
+type declared_age_pref = {
+  is_over_age13 : bool option;  (** Indicates if the user has declared that they are over 13 years of age. *)
+  is_over_age16 : bool option;  (** Indicates if the user has declared that they are over 16 years of age. *)
+  is_over_age18 : bool option;  (** Indicates if the user has declared that they are over 18 years of age. *)
 }
 
-(** Jsont codec for {!type:verification_prefs}. *)
-val verification_prefs_jsont : verification_prefs Jsont.t
+(** Jsont codec for {!type:declared_age_pref}. *)
+val declared_age_pref_jsont : declared_age_pref Jsont.t
 
-(** Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly. *)
 
-type post_interaction_settings_pref = {
-  threadgate_allow_rules : Jsont.json list option;  (** Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply. *)
-  postgate_embedding_rules : Jsont.json list option;  (** Matches postgate record. List of rules defining who can embed this users posts. If value is an empty array or is undefined, no particular rules apply and anyone can embed. *)
+type content_label_pref = {
+  label : string;
+  labeler_did : string option;  (** Which labeler does this preference apply to? If undefined, applies globally. *)
+  visibility : string;
 }
 
-(** Jsont codec for {!type:post_interaction_settings_pref}. *)
-val post_interaction_settings_pref_jsont : post_interaction_settings_pref Jsont.t
+(** Jsont codec for {!type:content_label_pref}. *)
+val content_label_pref_jsont : content_label_pref Jsont.t
 
+(** If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress. *)
 
-type status_view = {
-  uri : string option;
-  cid : string option;
-  status : string;  (** The status for the account. *)
-  record : Jsont.json;
-  embed : Jsont.json option;  (** An optional embed associated with the status. *)
-  expires_at : string option;  (** The date when this status will expire. The application might choose to no longer return the status after expiration. *)
-  is_active : bool option;  (** True if the status is not expired, false if it is expired. Only present if expiration was set. *)
-  is_disabled : bool option;  (** True if the user's go-live access has been disabled by a moderator, false otherwise. *)
+type bsky_app_progress_guide = {
+  guide : string;
 }
 
-(** Jsont codec for {!type:status_view}. *)
-val status_view_jsont : status_view Jsont.t
+(** Jsont codec for {!type:bsky_app_progress_guide}. *)
+val bsky_app_progress_guide_jsont : bsky_app_progress_guide Jsont.t
 
 
-type profile_associated = {
-  lists : int option;
-  feedgens : int option;
-  starter_packs : int option;
-  labeler : bool option;
-  chat : Jsont.json option;
-  activity_subscription : Jsont.json option;
+type adult_content_pref = {
+  enabled : bool;
 }
 
-(** Jsont codec for {!type:profile_associated}. *)
-val profile_associated_jsont : profile_associated Jsont.t
+(** Jsont codec for {!type:adult_content_pref}. *)
+val adult_content_pref_jsont : adult_content_pref Jsont.t
 
 (** Represents the verification information about the user this object is attached to. *)
 
 type verification_state = {
+  trusted_verifier_status : string;  (** The user's status as a trusted verifier. *)
   verifications : Jsont.json list;  (** All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included. *)
   verified_status : string;  (** The user's status as a verified account. *)
-  trusted_verifier_status : string;  (** The user's status as a trusted verifier. *)
 }
 
 (** Jsont codec for {!type:verification_state}. *)
···
 (** Jsont codec for {!type:saved_feeds_pref_v2}. *)
 val saved_feeds_pref_v2_jsont : saved_feeds_pref_v2 Jsont.t
 
+
+type profile_associated = {
+  activity_subscription : Jsont.json option;
+  chat : Jsont.json option;
+  feedgens : int option;
+  labeler : bool option;
+  lists : int option;
+  starter_packs : int option;
+}
+
+(** Jsont codec for {!type:profile_associated}. *)
+val profile_associated_jsont : profile_associated Jsont.t
+
 (** A word that the account owner has muted. *)
 
 type muted_word = {
+  actor_target : string option;  (** Groups of users to apply the muted word to. If undefined, applies to all users. *)
+  expires_at : string option;  (** The date and time at which the muted word will expire and no longer be applied. *)
   id : string option;
-  value : string;  (** The muted word itself. *)
   targets : Jsont.json list;  (** The intended targets of the muted word. *)
-  actor_target : string option;  (** Groups of users to apply the muted word to. If undefined, applies to all users. *)
-  expires_at : string option;  (** The date and time at which the muted word will expire and no longer be applied. *)
+  value : string;  (** The muted word itself. *)
 }
 
 (** Jsont codec for {!type:muted_word}. *)
···
 
 type bsky_app_state_pref = {
   active_progress_guide : Jsont.json option;
-  queued_nudges : string list option;  (** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. *)
   nuxs : Jsont.json list option;  (** Storage for NUXs the user has encountered. *)
+  queued_nudges : string list option;  (** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. *)
 }
 
 (** Jsont codec for {!type:bsky_app_state_pref}. *)
···
 (** Jsont codec for {!type:muted_words_pref}. *)
 val muted_words_pref_jsont : muted_words_pref Jsont.t
 
+(** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. *)
 
-type profile_view_basic = {
-  did : string;
-  handle : string;
-  display_name : string option;
-  pronouns : string option;
-  avatar : string option;
-  associated : Jsont.json option;
-  viewer : Jsont.json option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  created_at : string option;
-  verification : Jsont.json option;
-  status : Jsont.json option;
-  debug : Jsont.json option;  (** Debug information for internal development *)
+type viewer_state = {
+  activity_subscription : Jsont.json option;  (** This property is present only in selected cases, as an optimization. *)
+  blocked_by : bool option;
+  blocking : string option;
+  blocking_by_list : Jsont.json option;
+  followed_by : string option;
+  following : string option;
+  known_followers : Jsont.json option;  (** This property is present only in selected cases, as an optimization. *)
+  muted : bool option;
+  muted_by_list : Jsont.json option;
 }
 
-(** Jsont codec for {!type:profile_view_basic}. *)
-val profile_view_basic_jsont : profile_view_basic Jsont.t
+(** Jsont codec for {!type:viewer_state}. *)
+val viewer_state_jsont : viewer_state Jsont.t
 
 
-type profile_view = {
-  did : string;
-  handle : string;
-  display_name : string option;
-  pronouns : string option;
-  description : string option;
-  avatar : string option;
+type profile_view_detailed = {
   associated : Jsont.json option;
-  indexed_at : string option;
+  avatar : string option;
+  banner : string option;
   created_at : string option;
-  viewer : Jsont.json option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  verification : Jsont.json option;
-  status : Jsont.json option;
   debug : Jsont.json option;  (** Debug information for internal development *)
-}
-
-(** Jsont codec for {!type:profile_view}. *)
-val profile_view_jsont : profile_view Jsont.t
-
-
-type profile_view_detailed = {
+  description : string option;
   did : string;
-  handle : string;
   display_name : string option;
-  description : string option;
-  pronouns : string option;
-  website : string option;
-  avatar : string option;
-  banner : string option;
   followers_count : int option;
   follows_count : int option;
-  posts_count : int option;
-  associated : Jsont.json option;
-  joined_via_starter_pack : Jsont.json option;
+  handle : string;
   indexed_at : string option;
-  created_at : string option;
-  viewer : Jsont.json option;
+  joined_via_starter_pack : Jsont.json option;
   labels : Com.Atproto.Label.Defs.label list option;
   pinned_post : Com.Atproto.Repo.StrongRef.main option;
-  verification : Jsont.json option;
+  posts_count : int option;
+  pronouns : string option;
   status : Jsont.json option;
-  debug : Jsont.json option;  (** Debug information for internal development *)
+  verification : Jsont.json option;
+  viewer : Jsont.json option;
+  website : string option;
 }
 
 (** Jsont codec for {!type:profile_view_detailed}. *)
 val profile_view_detailed_jsont : profile_view_detailed Jsont.t
 
-(** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. *)
 
-type viewer_state = {
-  muted : bool option;
-  muted_by_list : Jsont.json option;
-  blocked_by : bool option;
-  blocking : string option;
-  blocking_by_list : Jsont.json option;
-  following : string option;
-  followed_by : string option;
-  known_followers : Jsont.json option;  (** This property is present only in selected cases, as an optimization. *)
-  activity_subscription : Jsont.json option;  (** This property is present only in selected cases, as an optimization. *)
+type profile_view_basic = {
+  associated : Jsont.json option;
+  avatar : string option;
+  created_at : string option;
+  debug : Jsont.json option;  (** Debug information for internal development *)
+  did : string;
+  display_name : string option;
+  handle : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  pronouns : string option;
+  status : Jsont.json option;
+  verification : Jsont.json option;
+  viewer : Jsont.json option;
 }
 
-(** Jsont codec for {!type:viewer_state}. *)
-val viewer_state_jsont : viewer_state Jsont.t
+(** Jsont codec for {!type:profile_view_basic}. *)
+val profile_view_basic_jsont : profile_view_basic Jsont.t
+
+
+type profile_view = {
+  associated : Jsont.json option;
+  avatar : string option;
+  created_at : string option;
+  debug : Jsont.json option;  (** Debug information for internal development *)
+  description : string option;
+  did : string;
+  display_name : string option;
+  handle : string;
+  indexed_at : string option;
+  labels : Com.Atproto.Label.Defs.label list option;
+  pronouns : string option;
+  status : Jsont.json option;
+  verification : Jsont.json option;
+  viewer : Jsont.json option;
+}
+
+(** Jsont codec for {!type:profile_view}. *)
+val profile_view_jsont : profile_view Jsont.t
 
 (** The subject's followers whom you also follow *)
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  term : string option;  (** DEPRECATED: use 'q' instead. *)
-  q : string option;  (** Search query prefix; not a full query string. *)
   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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  term : string option;  (** DEPRECATED: use 'q' instead. *)
+  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. *)
-  limit : int option;
-  cursor : string option;
+  term : string option;  (** DEPRECATED: use 'q' instead. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cursor : string option;
   actors : Jsont.json list;
+  cursor : string option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cursor : string option;
   actors : Jsont.json list;
+  cursor : string option;
   rec_id : int option;  (** Snowflake for this recommendation, use when submitting recommendation events. *)
 }
 
···
     end
     module Contact : sig
       module Defs : sig
-(** 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 = {
-  match_ : Jsont.json;  (** Profile of the matched user. *)
-  contact_index : int;  (** The index of this match in the import contact input. *)
-}
-
-(** Jsont codec for {!type:match_and_contact_index}. *)
-val match_and_contact_index_jsont : match_and_contact_index Jsont.t
-
 
 type sync_status = {
-  synced_at : string;  (** Last date when contacts where imported. *)
   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}. *)
···
 (** 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 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:match_and_contact_index}. *)
+val match_and_contact_index_jsont : match_and_contact_index Jsont.t
+
       end
       module RemoveData : sig
 (** Removes all stored hashes used for contact matching, existing matches, and sync status. Requires authentication. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type input = {
-  phone : string;  (** The phone number to verify. Should be the same as the one passed to `app.bsky.contact.startPhoneVerification`. *)
   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`. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type input = {
-  token : string;  (** JWT to authenticate the call. Use the JWT received as a response to the call to `app.bsky.contact.verifyPhone`. *)
   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:input}. *)
···
 (** Record defining a starter pack of actors and feeds for new users. *)
 
 type main = {
-  name : string;  (** Display name for starter pack; can not be empty. *)
+  created_at : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  list_ : string;  (** Reference (AT-URI) to the list record. *)
   feeds : Jsont.json list option;
-  created_at : string;
+  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}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   follows : Jsont.json list;
+  subject : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 type output = {
-  suggestions : Jsont.json list;
   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}. *)
···
 (** Record declaring a 'block' relationship against another account. NOTE: blocks are public in Bluesky; see blog posts for details. *)
 
 type main = {
-  subject : string;  (** DID of the account to be blocked. *)
   created_at : string;
+  subject : string;  (** DID of the account to be blocked. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** Record representing a block relationship against an entire an entire list of accounts (actors). *)
 
 type main = {
-  subject : string;  (** Reference (AT-URI) to the mod list record. *)
   created_at : string;
+  subject : string;  (** Reference (AT-URI) to the mod list record. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
+  cursor : string option;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 (** Record declaring a social 'follow' relationship of another account. Duplicate follows will be ignored by the AppView. *)
 
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
   via : Com.Atproto.Repo.StrongRef.main option;
 }
 
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  subject : Jsont.json;
   cursor : string option;
   followers : Jsont.json list;
+  subject : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 (** Record representing an account's inclusion on a specific list. The AppView will ignore duplicate listitem records. *)
 
 type main = {
-  subject : string;  (** The account which is included on the list. *)
+  created_at : string;
   list_ : string;  (** Reference (AT-URI) to the list record (app.bsky.graph.list). *)
-  created_at : string;
+  subject : string;  (** The account which is included on the list. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
       end
       module Defs : sig
 
-type list_item_view = {
-  uri : string;
-  subject : Jsont.json;
-}
-
-(** Jsont codec for {!type:list_item_view}. *)
-val list_item_view_jsont : list_item_view Jsont.t
-
-
 type starter_pack_view_basic = {
-  uri : string;
   cid : string;
-  record : Jsont.json;
   creator : Jsont.json;
-  list_item_count : int option;
+  indexed_at : string;
+  joined_all_time_count : int option;
   joined_week_count : int option;
-  joined_all_time_count : int option;
   labels : Com.Atproto.Label.Defs.label list option;
-  indexed_at : string;
+  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 list_purpose = string
-val list_purpose_jsont : list_purpose Jsont.t
-
-(** A list of actors to apply an aggregate moderation action (mute/block) on. *)
-
-type modlist = string
-val modlist_jsont : modlist Jsont.t
-
-(** A list of actors used for curation purposes such as list feeds or interaction gating. *)
+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 *)
+}
 
-type curatelist = string
-val curatelist_jsont : curatelist 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 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;
-  blocked : string option;
 }
 
 (** Jsont codec for {!type:list_viewer_state}. *)
 val list_viewer_state_jsont : list_viewer_state Jsont.t
 
-(** indicates that a handle or DID could not be resolved *)
 
-type not_found_actor = {
-  actor : string;
-  not_found : bool;
+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:not_found_actor}. *)
-val not_found_actor_jsont : not_found_actor Jsont.t
+(** Jsont codec for {!type:list_item_view}. *)
+val list_item_view_jsont : list_item_view 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) *)
+(** A list of actors used for curation purposes such as list feeds or interaction gating. *)
 
-type relationship = {
-  did : string;
-  following : string option;  (** if the actor follows this DID, this is the AT-URI of the follow record *)
-  followed_by : string option;  (** if the actor is followed by this DID, contains the AT-URI of the follow record *)
-  blocking : string option;  (** if the actor blocks this DID, this is the AT-URI of the block record *)
-  blocked_by : string option;  (** if the actor is blocked by this DID, contains 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 *)
-  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 *)
-}
-
-(** Jsont codec for {!type:relationship}. *)
-val relationship_jsont : relationship Jsont.t
+type curatelist = string
+val curatelist_jsont : curatelist Jsont.t
 
 
 type list_view_basic = {
-  uri : string;
+  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;
-  avatar : string option;
-  list_item_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
+  uri : string;
   viewer : Jsont.json option;
-  indexed_at : string option;
 }
 
 (** Jsont codec for {!type:list_view_basic}. *)
···
 
 
 type list_view = {
-  uri : string;
+  avatar : string option;
   cid : string;
   creator : Jsont.json;
-  name : string;
-  purpose : Jsont.json;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : string option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
   list_item_count : int option;
-  labels : Com.Atproto.Label.Defs.label list option;
+  name : string;
+  purpose : Jsont.json;
+  uri : string;
   viewer : Jsont.json option;
-  indexed_at : string;
 }
 
 (** Jsont codec for {!type:list_view}. *)
···
 
 
 type starter_pack_view = {
-  uri : string;
   cid : string;
-  record : Jsont.json;
   creator : Jsont.json;
-  list_ : Jsont.json option;
-  list_items_sample : Jsont.json list option;
   feeds : Jsont.json list option;
+  indexed_at : string;
+  joined_all_time_count : int option;
   joined_week_count : int option;
-  joined_all_time_count : int option;
   labels : Com.Atproto.Label.Defs.label list option;
-  indexed_at : string;
+  list_ : Jsont.json option;
+  list_items_sample : Jsont.json list option;
+  record : Jsont.json;
+  uri : string;
 }
 
 (** Jsont codec for {!type:starter_pack_view}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cursor : string option;
   blocks : Jsont.json list;
+  cursor : string option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 (** 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. *)
-  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. *)
-  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. *)
-  created_at : string;  (** Date of when the verification was created. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** A starter pack and an optional list item indicating membership of a target user to that starter pack. *)
 
 type starter_pack_with_membership = {
-  starter_pack : Jsont.json;
   list_item : Jsont.json option;
+  starter_pack : Jsont.json;
 }
 
 (** Jsont codec for {!type:starter_pack_with_membership}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;  (** The account (actor) to check for membership. *)
+  cursor : string option;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Record representing a list of accounts (actors). Scope includes both moderation-oriented lists and curration-oriented lists. *)
 
 type main = {
-  purpose : Jsont.json;  (** Defines the purpose of the list (aka, moderation-oriented or curration-oriented) *)
-  name : string;  (** Display name for list; can not be empty. *)
+  avatar : Atp.Blob_ref.t option;
+  created_at : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : Atp.Blob_ref.t option;
   labels : Com.Atproto.Label.Defs.self_labels option;
-  created_at : string;
+  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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  q : string;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  q : string;  (** Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  list_ : string;  (** Reference (AT-URI) of the list record to hydrate. *)
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  list_ : string;  (** Reference (AT-URI) of the list record to hydrate. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 type output = {
   cursor : string option;
-  list_ : Jsont.json;
   items : Jsont.json list;
+  list_ : Jsont.json;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;  (** The account (actor) to check for membership. *)
-  limit : int option;
   cursor : string option;
+  limit : int option;
   purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;  (** The account (actor) to enumerate lists from. *)
+  cursor : string option;
   limit : int option;
-  cursor : string option;
   purposes : string list option;  (** Optional filter by list purpose. If not specified, all supported types are returned. *)
 }
 
···
     end
     module Feed : sig
       module Post : sig
-
-type reply_ref = {
-  root : Com.Atproto.Repo.StrongRef.main;
-  parent : Com.Atproto.Repo.StrongRef.main;
-}
-
-(** Jsont codec for {!type:reply_ref}. *)
-val reply_ref_jsont : reply_ref Jsont.t
-
 (** 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;
-  end_ : 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 = {
···
 (** Record containing a Bluesky post. *)
 
 type main = {
-  text : string;  (** The primary post content. May be an empty string, if there are embeds. *)
+  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;
-  embed : Jsont.json option;
-  langs : string list option;  (** Indicates human language of post primary text content. *)
-  labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values for this post. Effectively content warnings. *)
   tags : string list option;  (** Additional hashtags, in addition to any included in post text and facets. *)
-  created_at : string;  (** Client-declared timestamp when this post was originally created. *)
+  text : string;  (** The primary post content. May be an empty string, if there are embeds. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module GetLikes : sig
 
 type like = {
-  indexed_at : string;
+  actor : Jsont.json;
   created_at : string;
-  actor : Jsont.json;
+  indexed_at : string;
 }
 
 (** Jsont codec for {!type:like}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  uri : string;  (** AT-URI of the subject (eg, a post record). *)
   cid : string option;  (** CID of the subject record (aka, specific version of record), to filter likes. *)
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  uri : string;  (** AT-URI of the subject (eg, a post record). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   likes : Jsont.json list;
+  uri : string;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 type main = {
   created_at : string;
-  post : string;  (** Reference (AT-URI) to the post record. *)
   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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  uri : string;  (** Reference (AT-URI) of post record *)
   cid : string option;  (** If supplied, filters to reposts of specific version (by CID) of the post record. *)
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  uri : string;  (** Reference (AT-URI) of post record *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   reposted_by : Jsont.json list;
+  uri : string;
 }
 
 (** Jsont codec for {!type:output}. *)
···
       end
       module DescribeFeedGenerator : sig
 
-type feed = {
-  uri : string;
-}
-
-(** Jsont codec for {!type:feed}. *)
-val feed_jsont : feed Jsont.t
-
-
 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). *)
 
···
 (** Jsont codec for {!type:mention_rule}. *)
 val mention_rule_jsont : mention_rule Jsont.t
 
-(** Allow replies from actors who follow you. *)
+(** Allow replies from actors on a list. *)
 
-type follower_rule = unit
+type list_rule = {
+  list_ : string;
+}
 
-(** Jsont codec for {!type:follower_rule}. *)
-val follower_rule_jsont : follower_rule Jsont.t
+(** Jsont codec for {!type:list_rule}. *)
+val list_rule_jsont : list_rule Jsont.t
 
 (** Allow replies from actors you follow. *)
 
···
 (** Jsont codec for {!type:following_rule}. *)
 val following_rule_jsont : following_rule Jsont.t
 
-(** Allow replies from actors on a list. *)
+(** Allow replies from actors who follow you. *)
 
-type list_rule = {
-  list_ : string;
-}
+type follower_rule = unit
 
-(** Jsont codec for {!type:list_rule}. *)
-val list_rule_jsont : list_rule Jsont.t
+(** 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 = {
-  post : string;  (** Reference (AT-URI) to the post record. *)
   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. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** Record declaring a 'like' of a piece of subject content. *)
 
 type main = {
-  subject : Com.Atproto.Repo.StrongRef.main;
   created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
   via : Com.Atproto.Repo.StrongRef.main option;
 }
 
···
 (** Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests. *)
 
 type viewer_state = {
-  repost : string option;
-  like : string option;
   bookmarked : bool option;
-  thread_muted : bool option;
-  reply_disabled : bool option;
   embedding_disabled : bool option;
+  like : string option;
   pinned : bool option;
+  reply_disabled : bool option;
+  repost : string option;
+  thread_muted : bool option;
 }
 
 (** Jsont codec for {!type:viewer_state}. *)
 val viewer_state_jsont : viewer_state Jsont.t
+
+
+type threadgate_view = {
+  cid : string option;
+  lists : Jsont.json list option;
+  record : Jsont.json option;
+  uri : string option;
+}
+
+(** Jsont codec for {!type:threadgate_view}. *)
+val threadgate_view_jsont : threadgate_view Jsont.t
 
 (** Metadata about this post within the context of the thread it is in. *)
 
···
 val thread_context_jsont : thread_context Jsont.t
 
 
+type skeleton_reason_repost = {
+  repost : string;
+}
+
+(** Jsont codec for {!type:skeleton_reason_repost}. *)
+val skeleton_reason_repost_jsont : skeleton_reason_repost Jsont.t
+
+
+type skeleton_reason_pin = unit
+
+(** Jsont codec for {!type:skeleton_reason_pin}. *)
+val skeleton_reason_pin_jsont : skeleton_reason_pin Jsont.t
+
+
+type skeleton_feed_post = {
+  feed_context : string option;  (** Context that will be passed through to client and may be passed to feed generator back alongside interactions. *)
+  post : string;
+  reason : Jsont.json option;
+}
+
+(** Jsont codec for {!type:skeleton_feed_post}. *)
+val skeleton_feed_post_jsont : skeleton_feed_post Jsont.t
+
+(** Request that more content like the given feed item be shown in the feed *)
+
+type request_more = string
+val request_more_jsont : request_more Jsont.t
+
+(** Request that less content like the given feed item be shown in the feed *)
+
+type request_less = string
+val request_less_jsont : request_less Jsont.t
+
+
 type reply_ref = {
-  root : Jsont.json;
-  parent : Jsont.json;
   grandparent_author : Jsont.json option;  (** When parent is a reply to another post, this is the author of that post. *)
+  parent : Jsont.json;
+  root : Jsont.json;
 }
 
 (** Jsont codec for {!type:reply_ref}. *)
···
 
 type reason_repost = {
   by : Jsont.json;
-  uri : string option;
   cid : string option;
   indexed_at : string;
+  uri : string option;
 }
 
 (** Jsont codec for {!type:reason_repost}. *)
···
 
 
 type not_found_post = {
+  not_found : bool;
   uri : string;
-  not_found : bool;
 }
 
 (** Jsont codec for {!type:not_found_post}. *)
 val not_found_post_jsont : not_found_post Jsont.t
 
+(** User shared the feed item *)
 
-type blocked_author = {
-  did : string;
-  viewer : Jsont.json option;
-}
+type interaction_share = string
+val interaction_share_jsont : interaction_share Jsont.t
 
-(** Jsont codec for {!type:blocked_author}. *)
-val blocked_author_jsont : blocked_author Jsont.t
+(** Feed item was seen by user *)
 
+type interaction_seen = string
+val interaction_seen_jsont : interaction_seen Jsont.t
 
-type generator_viewer_state = {
-  like : string option;
-}
+(** User reposted the feed item *)
 
-(** Jsont codec for {!type:generator_viewer_state}. *)
-val generator_viewer_state_jsont : generator_viewer_state Jsont.t
+type interaction_repost = string
+val interaction_repost_jsont : interaction_repost Jsont.t
 
+(** User replied to the feed item *)
 
-type skeleton_feed_post = {
-  post : string;
-  reason : Jsont.json option;
-  feed_context : string option;  (** Context that will be passed through to client and may be passed to feed generator back alongside interactions. *)
-}
+type interaction_reply = string
+val interaction_reply_jsont : interaction_reply Jsont.t
 
-(** Jsont codec for {!type:skeleton_feed_post}. *)
-val skeleton_feed_post_jsont : skeleton_feed_post Jsont.t
+(** User quoted the feed item *)
 
+type interaction_quote = string
+val interaction_quote_jsont : interaction_quote Jsont.t
 
-type skeleton_reason_repost = {
-  repost : string;
-}
+(** User liked the feed item *)
 
-(** Jsont codec for {!type:skeleton_reason_repost}. *)
-val skeleton_reason_repost_jsont : skeleton_reason_repost Jsont.t
-
-
-type skeleton_reason_pin = unit
-
-(** Jsont codec for {!type:skeleton_reason_pin}. *)
-val skeleton_reason_pin_jsont : skeleton_reason_pin Jsont.t
-
-
-type threadgate_view = {
-  uri : string option;
-  cid : string option;
-  record : Jsont.json option;
-  lists : Jsont.json list option;
-}
-
-(** Jsont codec for {!type:threadgate_view}. *)
-val threadgate_view_jsont : threadgate_view Jsont.t
+type interaction_like = string
+val interaction_like_jsont : interaction_like Jsont.t
 
 
 type interaction = {
-  item : string option;
   event : string option;
   feed_context : string option;  (** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. *)
+  item : string option;
   req_id : string option;  (** Unique identifier per request that may be passed back alongside interactions. *)
 }
 
 (** Jsont codec for {!type:interaction}. *)
 val interaction_jsont : interaction Jsont.t
 
-(** Request that less content like the given feed item be shown in the feed *)
 
-type request_less = string
-val request_less_jsont : request_less Jsont.t
+type generator_viewer_state = {
+  like : string option;
+}
 
-(** Request that more content like the given feed item be shown in the feed *)
+(** Jsont codec for {!type:generator_viewer_state}. *)
+val generator_viewer_state_jsont : generator_viewer_state Jsont.t
 
-type request_more = string
-val request_more_jsont : request_more Jsont.t
+(** Declares the feed generator returns posts containing app.bsky.embed.video embeds. *)
 
-(** User clicked through to the feed item *)
+type content_mode_video = string
+val content_mode_video_jsont : content_mode_video Jsont.t
 
-type clickthrough_item = string
-val clickthrough_item_jsont : clickthrough_item Jsont.t
+(** Declares the feed generator returns any types of posts. *)
 
-(** User clicked through to the author of the feed item *)
-
-type clickthrough_author = string
-val clickthrough_author_jsont : clickthrough_author Jsont.t
+type content_mode_unspecified = string
+val content_mode_unspecified_jsont : content_mode_unspecified Jsont.t
 
 (** User clicked through to the reposter of the feed item *)
 
 type clickthrough_reposter = string
 val clickthrough_reposter_jsont : clickthrough_reposter Jsont.t
 
+(** User clicked through to the feed item *)
+
+type clickthrough_item = string
+val clickthrough_item_jsont : clickthrough_item Jsont.t
+
 (** User clicked through to the embedded content of the feed item *)
 
 type clickthrough_embed = string
 val clickthrough_embed_jsont : clickthrough_embed Jsont.t
 
-(** Declares the feed generator returns any types of posts. *)
+(** User clicked through to the author of the feed item *)
 
-type content_mode_unspecified = string
-val content_mode_unspecified_jsont : content_mode_unspecified Jsont.t
+type clickthrough_author = string
+val clickthrough_author_jsont : clickthrough_author Jsont.t
 
-(** Declares the feed generator returns posts containing app.bsky.embed.video embeds. *)
-
-type content_mode_video = string
-val content_mode_video_jsont : content_mode_video Jsont.t
-
-(** Feed item was seen by user *)
-
-type interaction_seen = string
-val interaction_seen_jsont : interaction_seen Jsont.t
-
-(** User liked the feed item *)
-
-type interaction_like = string
-val interaction_like_jsont : interaction_like Jsont.t
-
-(** User reposted the feed item *)
-
-type interaction_repost = string
-val interaction_repost_jsont : interaction_repost Jsont.t
-
-(** User replied to the feed item *)
-
-type interaction_reply = string
-val interaction_reply_jsont : interaction_reply Jsont.t
-
-(** User quoted the feed item *)
 
-type interaction_quote = string
-val interaction_quote_jsont : interaction_quote Jsont.t
-
-(** User shared the feed item *)
+type blocked_author = {
+  did : string;
+  viewer : Jsont.json option;
+}
 
-type interaction_share = string
-val interaction_share_jsont : interaction_share Jsont.t
+(** Jsont codec for {!type:blocked_author}. *)
+val blocked_author_jsont : blocked_author Jsont.t
 
 
 type post_view = {
-  uri : string;
+  author : Jsont.json;
+  bookmark_count : int option;
   cid : string;
-  author : Jsont.json;
+  debug : Jsont.json option;  (** Debug information for internal development *)
+  embed : Jsont.json option;
+  indexed_at : string;
+  labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  quote_count : int option;
   record : Jsont.json;
-  embed : Jsont.json option;
-  bookmark_count : int option;
   reply_count : int option;
   repost_count : int option;
-  like_count : int option;
-  quote_count : int option;
-  indexed_at : string;
+  threadgate : Jsont.json option;
+  uri : string;
   viewer : Jsont.json option;
-  labels : Com.Atproto.Label.Defs.label list option;
-  threadgate : Jsont.json option;
-  debug : Jsont.json option;  (** Debug information for internal development *)
 }
 
 (** Jsont codec for {!type:post_view}. *)
 val post_view_jsont : post_view Jsont.t
 
 
-type blocked_post = {
-  uri : string;
-  blocked : bool;
-  author : Jsont.json;
-}
-
-(** Jsont codec for {!type:blocked_post}. *)
-val blocked_post_jsont : blocked_post Jsont.t
-
-
 type generator_view = {
-  uri : string;
+  accepts_interactions : bool option;
+  avatar : string option;
   cid : string;
-  did : string;
+  content_mode : string option;
   creator : Jsont.json;
-  display_name : string;
   description : string option;
   description_facets : Richtext.Facet.main list option;
-  avatar : string option;
-  like_count : int option;
-  accepts_interactions : bool option;
+  did : string;
+  display_name : string;
+  indexed_at : string;
   labels : Com.Atproto.Label.Defs.label list option;
+  like_count : int option;
+  uri : string;
   viewer : Jsont.json option;
-  content_mode : string option;
-  indexed_at : string;
 }
 
 (** Jsont codec for {!type:generator_view}. *)
 val generator_view_jsont : generator_view Jsont.t
 
 
-type feed_view_post = {
-  post : Jsont.json;
-  reply : Jsont.json option;
-  reason : Jsont.json option;
-  feed_context : string option;  (** Context provided by feed generator that may be passed back alongside interactions. *)
-  req_id : string option;  (** Unique identifier per request that may be passed back alongside interactions. *)
+type blocked_post = {
+  author : Jsont.json;
+  blocked : bool;
+  uri : string;
 }
 
-(** Jsont codec for {!type:feed_view_post}. *)
-val feed_view_post_jsont : feed_view_post Jsont.t
+(** Jsont codec for {!type:blocked_post}. *)
+val blocked_post_jsont : blocked_post Jsont.t
 
 
 type thread_view_post = {
-  post : Jsont.json;
   parent : Jsont.json option;
+  post : Jsont.json;
   replies : Jsont.json list option;
   thread_context : Jsont.json option;
 }
···
 (** Jsont codec for {!type:thread_view_post}. *)
 val thread_view_post_jsont : thread_view_post Jsont.t
 
+
+type feed_view_post = {
+  feed_context : string option;  (** Context provided by feed generator that may be passed back alongside interactions. *)
+  post : Jsont.json;
+  reason : Jsont.json option;
+  reply : Jsont.json option;
+  req_id : string option;  (** Unique identifier per request that may be passed back alongside interactions. *)
+}
+
+(** Jsont codec for {!type:feed_view_post}. *)
+val feed_view_post_jsont : feed_view_post Jsont.t
+
       end
       module Repost : sig
 (** Record representing a 'repost' of an existing Bluesky post. *)
 
 type main = {
-  subject : Com.Atproto.Repo.StrongRef.main;
   created_at : string;
+  subject : Com.Atproto.Repo.StrongRef.main;
   via : Com.Atproto.Repo.StrongRef.main option;
 }
 
···
 (** Record declaring of the existence of a feed generator, and containing metadata about it. The record can exist in any repository. *)
 
 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;
-  description : string option;
-  description_facets : Richtext.Facet.main list option;
-  avatar : Atp.Blob_ref.t option;
-  accepts_interactions : bool option;  (** Declaration that a feed accepts feedback interactions from a client through app.bsky.feed.sendInteractions *)
   labels : Com.Atproto.Label.Defs.self_labels option;  (** Self-label values *)
-  content_mode : string option;
-  created_at : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  uri : string;  (** Reference (AT-URI) to 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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;
   feed : string;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  uri : string;  (** Reference (AT-URI) of post record *)
   cid : string option;  (** If supplied, filters to quotes of specific version (by CID) of the post record. *)
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  uri : string;  (** Reference (AT-URI) of post record *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  uri : string;
   cid : string option;
   cursor : string option;
   posts : Jsont.json list;
+  uri : string;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  list_ : string;  (** Reference (AT-URI) to the list record. *)
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  list_ : string;  (** Reference (AT-URI) to the list record. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;
   feed : string;  (** Reference to feed generator record describing the specific feed being requested. *)
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** 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. *)
-  sort : string option;  (** Specifies the ranking order of results. *)
   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). *)
-  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. *)
-  author : string option;  (** Filter to posts by the given account. Handles are resolved to DID before query-time. *)
-  lang : string option;  (** Filter to posts in the given language. Expected to be based on post language field, though server may override language detection. *)
-  domain : string option;  (** Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization. *)
   url : string option;  (** Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching. *)
-  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. *)
-  limit : int option;
-  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
   filter : string option;  (** Combinations of post/repost types to include in response. *)
   include_pins : bool option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  view : 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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** Query/procedure parameters. *)
 type params = {
   actor : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 (** 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. *)
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type input = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
       end
       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 = {
···
 (** Jsont codec for {!type:bookmark}. *)
 val bookmark_jsont : bookmark Jsont.t
 
-
-type bookmark_view = {
-  subject : Com.Atproto.Repo.StrongRef.main;  (** A strong ref to the bookmarked record. *)
-  created_at : string option;
-  item : Jsont.json;
-}
-
-(** Jsont codec for {!type:bookmark_view}. *)
-val bookmark_view_jsont : bookmark_view Jsont.t
-
       end
       module GetBookmarks : sig
 (** Gets views of records bookmarked by the authenticated user. Requires authentication. *)
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;
   limit : int option;
-  cursor : string option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  cursor : string option;
   bookmarks : Defs.bookmark_view list;
+  cursor : string option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
   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}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
   query : string option;
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
   limit : int option;
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  limit : int option;
   viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
-  limit : int option;
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
   limit : int option;
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
       end
       module Defs : sig
 
-type skeleton_search_post = {
-  uri : string;
-}
-
-(** Jsont codec for {!type:skeleton_search_post}. *)
-val skeleton_search_post_jsont : skeleton_search_post Jsont.t
-
-
-type skeleton_search_actor = {
-  did : string;
-}
-
-(** Jsont codec for {!type:skeleton_search_actor}. *)
-val skeleton_search_actor_jsont : skeleton_search_actor Jsont.t
-
-
-type skeleton_search_starter_pack = {
-  uri : string;
-}
-
-(** Jsont codec for {!type:skeleton_search_starter_pack}. *)
-val skeleton_search_starter_pack_jsont : skeleton_search_starter_pack Jsont.t
-
-
 type trending_topic = {
-  topic : string;
-  display_name : string option;
   description : string option;
+  display_name : string option;
   link : string;
+  topic : string;
 }
 
 (** Jsont codec for {!type:trending_topic}. *)
 val trending_topic_jsont : trending_topic Jsont.t
 
 
-type skeleton_trend = {
-  topic : string;
-  display_name : string;
-  link : string;
-  started_at : string;
-  post_count : int;
-  status : string option;
-  category : string option;
-  dids : string list;
-}
-
-(** Jsont codec for {!type:skeleton_trend}. *)
-val skeleton_trend_jsont : skeleton_trend Jsont.t
-
-
 type trend_view = {
-  topic : string;
+  actors : Jsont.json list;
+  category : string option;
   display_name : string;
   link : string;
-  started_at : string;
   post_count : int;
+  started_at : string;
   status : string option;
-  category : string option;
-  actors : Jsont.json list;
+  topic : string;
 }
 
 (** Jsont codec for {!type:trend_view}. *)
···
 
 
 type thread_item_post = {
-  post : Jsont.json;
+  hidden_by_threadgate : bool;  (** The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread. *)
   more_parents : bool;  (** This post has more parents that were not present in the response. This is just a boolean, without the number of parents. *)
   more_replies : int;  (** This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate. *)
+  muted_by_viewer : bool;  (** This is by an account muted by the viewer requesting it. *)
   op_thread : bool;  (** This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread. *)
-  hidden_by_threadgate : bool;  (** The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread. *)
-  muted_by_viewer : bool;  (** This is by an account muted by the viewer requesting it. *)
+  post : Jsont.json;
 }
 
 (** Jsont codec for {!type:thread_item_post}. *)
 val thread_item_post_jsont : thread_item_post Jsont.t
 
 
+type thread_item_not_found = unit
+
+(** Jsont codec for {!type:thread_item_not_found}. *)
+val thread_item_not_found_jsont : thread_item_not_found Jsont.t
+
+
 type thread_item_no_unauthenticated = unit
 
 (** Jsont codec for {!type:thread_item_no_unauthenticated}. *)
 val thread_item_no_unauthenticated_jsont : thread_item_no_unauthenticated Jsont.t
 
 
-type thread_item_not_found = unit
-
-(** Jsont codec for {!type:thread_item_not_found}. *)
-val thread_item_not_found_jsont : thread_item_not_found Jsont.t
-
-
 type thread_item_blocked = {
   author : Jsont.json;
 }
···
 (** Jsont codec for {!type:thread_item_blocked}. *)
 val thread_item_blocked_jsont : thread_item_blocked Jsont.t
 
+
+type skeleton_trend = {
+  category : string option;
+  dids : string list;
+  display_name : string;
+  link : string;
+  post_count : int;
+  started_at : string;
+  status : string option;
+  topic : string;
+}
+
+(** Jsont codec for {!type:skeleton_trend}. *)
+val skeleton_trend_jsont : skeleton_trend Jsont.t
+
+
+type skeleton_search_starter_pack = {
+  uri : string;
+}
+
+(** Jsont codec for {!type:skeleton_search_starter_pack}. *)
+val skeleton_search_starter_pack_jsont : skeleton_search_starter_pack Jsont.t
+
+
+type skeleton_search_post = {
+  uri : string;
+}
+
+(** Jsont codec for {!type:skeleton_search_post}. *)
+val skeleton_search_post_jsont : skeleton_search_post Jsont.t
+
+
+type skeleton_search_actor = {
+  did : string;
+}
+
+(** Jsont codec for {!type:skeleton_search_actor}. *)
+val skeleton_search_actor_jsont : skeleton_search_actor Jsont.t
+
 (** The computed state of the age assurance process, returned to the user in question on certain authenticated requests. *)
 
 type age_assurance_state = {
···
 (** Object used to store age assurance data in stash. *)
 
 type age_assurance_event = {
+  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 AA flow. *)
+  complete_ua : string option;  (** The user agent used when completing the AA flow. *)
   created_at : string;  (** The date and time of this write operation. *)
-  status : string;  (** The status of the age assurance process. *)
-  attempt_id : string;  (** The unique identifier for this instance of the age assurance flow, in UUID format. *)
   email : string option;  (** The email used for AA. *)
   init_ip : string option;  (** The IP address used when initiating the AA flow. *)
   init_ua : string option;  (** The user agent used when initiating the AA flow. *)
-  complete_ip : string option;  (** The IP address used when completing the AA flow. *)
-  complete_ua : string option;  (** The user agent used when completing the AA flow. *)
+  status : string;  (** The status of the age assurance process. *)
 }
 
 (** Jsont codec for {!type:age_assurance_event}. *)
···
       module GetTaggedSuggestions : sig
 
 type suggestion = {
-  tag : string;
-  subject_type : string;
   subject : string;
+  subject_type : string;
+  tag : string;
 }
 
 (** Jsont codec for {!type:suggestion}. *)
···
 
 (** 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. *)
-  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). *)
+  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). *)
-  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. *)
-  author : string option;  (** Filter to posts by the given account. Handles are resolved to DID before query-time. *)
-  lang : string option;  (** Filter to posts in the given language. Expected to be based on post language field, though server may override language detection. *)
-  domain : string option;  (** Filter to posts with URLs (facet links or embeds) linking to the given domain (hostname). Server may apply hostname normalization. *)
   url : string option;  (** Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching. *)
-  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. *)
   viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used for 'from:me' queries. *)
-  limit : int option;
-  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
       module GetPostThreadV2 : sig
 
 type thread_item = {
-  uri : string;
   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;
 }
 
···
 
 (** 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. *)
-  above : bool option;  (** Whether to include parents above the anchor. *)
   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. *)
···
 
 
 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;
-  has_other_replies : bool;  (** Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them. *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
   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. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  topics : Defs.trending_topic list;
   suggested : Defs.trending_topic list;
+  topics : Defs.trending_topic list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
   limit : int option;
+  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
       module GetPostThreadOtherV2 : 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;
-  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. *)
   value : Defs.thread_item_post;
 }
 
···
 
 
 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. *)
-  country_code : string;  (** An ISO 3166-1 alpha-2 code of the user's location. *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
+  limit : int option;
   q : string;  (** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. *)
   viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). *)
-  limit : int option;
-  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
+  limit : int option;
   q : string;  (** Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax. *)
+  typeahead : bool option;  (** If true, acts as fast/simple 'typeahead' query. *)
   viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
-  typeahead : bool option;  (** If true, acts as fast/simple 'typeahead' query. *)
-  limit : int option;
-  cursor : string option;  (** Optional pagination mechanism; may not necessarily allow scrolling through entire result set. *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
+  actors : Defs.skeleton_search_actor list;
   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. *)
-  actors : Defs.skeleton_search_actor list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  viewer : string option;  (** DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking. *)
+  cursor : string option;
   limit : int option;
-  cursor : string 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 = {
-  cursor : string option;
   actors : Defs.skeleton_search_actor list;
-  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. *)
+  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}. *)

lexicons/standard-site/atp_lexicon_standard_site.ml

···
     module Repo = struct
       module StrongRef = struct
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ uri cid -> { uri; cid })
+    (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.mem "cid" Jsont.string ~enc:(fun r -> r.cid)
   |> Jsont.Object.finish
 
       end
···
     end
     module Document = struct
 type main = {
-  site : string;
-  path : string option;
-  title : string;
-  description : string option;
-  cover_image : Atp.Blob_ref.t option;
-  content : Jsont.json option;
-  text_content : string option;
   bsky_post_ref : Com.Atproto.Repo.StrongRef.main option;
+  content : Jsont.json option;
+  cover_image : Atp.Blob_ref.t option;
+  description : string option;
+  path : string option;
+  published_at : string;
+  site : string;
   tags : string list option;
-  published_at : string;
+  text_content : string option;
+  title : string;
   updated_at : string option;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ site path title description cover_image content text_content bsky_post_ref tags published_at updated_at -> { site; path; title; description; cover_image; content; text_content; bsky_post_ref; tags; published_at; updated_at })
+    (fun _typ bsky_post_ref content cover_image description path published_at site tags text_content title updated_at -> { bsky_post_ref; content; cover_image; description; path; published_at; site; tags; text_content; title; updated_at })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.document" ~enc:(fun _ -> "site.standard.document")
-  |> Jsont.Object.mem "site" Jsont.string ~enc:(fun r -> r.site)
-  |> Jsont.Object.opt_mem "path" Jsont.string ~enc:(fun r -> r.path)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
+  |> Jsont.Object.opt_mem "bskyPostRef" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.bsky_post_ref)
+  |> Jsont.Object.opt_mem "content" Jsont.json ~enc:(fun r -> r.content)
+  |> Jsont.Object.opt_mem "coverImage" Atp.Blob_ref.jsont ~enc:(fun r -> r.cover_image)
   |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "coverImage" Atp.Blob_ref.jsont ~enc:(fun r -> r.cover_image)
-  |> Jsont.Object.opt_mem "content" Jsont.json ~enc:(fun r -> r.content)
-  |> Jsont.Object.opt_mem "textContent" Jsont.string ~enc:(fun r -> r.text_content)
-  |> Jsont.Object.opt_mem "bskyPostRef" Com.Atproto.Repo.StrongRef.main_jsont ~enc:(fun r -> r.bsky_post_ref)
+  |> Jsont.Object.opt_mem "path" Jsont.string ~enc:(fun r -> r.path)
+  |> Jsont.Object.mem "publishedAt" Jsont.string ~enc:(fun r -> r.published_at)
+  |> Jsont.Object.mem "site" Jsont.string ~enc:(fun r -> r.site)
   |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
-  |> Jsont.Object.mem "publishedAt" Jsont.string ~enc:(fun r -> r.published_at)
+  |> Jsont.Object.opt_mem "textContent" Jsont.string ~enc:(fun r -> r.text_content)
+  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
   |> Jsont.Object.opt_mem "updatedAt" Jsont.string ~enc:(fun r -> r.updated_at)
   |> Jsont.Object.finish
 
     end
     module Theme = struct
       module Color = struct
-type rgb = {
-  r : int;
+type rgba = {
+  a : int;
+  b : int;
   g : int;
-  b : int;
+  r : int;
 }
 
-let rgb_jsont =
-  Jsont.Object.map ~kind:"Rgb"
-    (fun _typ r g b -> { r; g; b })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.theme.color#rgb" ~enc:(fun _ -> "site.standard.theme.color#rgb")
-  |> Jsont.Object.mem "r" Jsont.int ~enc:(fun r -> r.r)
+let rgba_jsont =
+  Jsont.Object.map ~kind:"Rgba"
+    (fun _typ a b g r -> { a; b; g; r })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.theme.color#rgba" ~enc:(fun _ -> "site.standard.theme.color#rgba")
+  |> Jsont.Object.mem "a" Jsont.int ~enc:(fun r -> r.a)
+  |> Jsont.Object.mem "b" Jsont.int ~enc:(fun r -> r.b)
   |> Jsont.Object.mem "g" Jsont.int ~enc:(fun r -> r.g)
-  |> Jsont.Object.mem "b" Jsont.int ~enc:(fun r -> r.b)
+  |> Jsont.Object.mem "r" Jsont.int ~enc:(fun r -> r.r)
   |> Jsont.Object.finish
 
-type rgba = {
-  r : int;
-  g : int;
+type rgb = {
   b : int;
-  a : int;
+  g : int;
+  r : int;
 }
 
-let rgba_jsont =
-  Jsont.Object.map ~kind:"Rgba"
-    (fun _typ r g b a -> { r; g; b; a })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.theme.color#rgba" ~enc:(fun _ -> "site.standard.theme.color#rgba")
-  |> Jsont.Object.mem "r" Jsont.int ~enc:(fun r -> r.r)
-  |> Jsont.Object.mem "g" Jsont.int ~enc:(fun r -> r.g)
+let rgb_jsont =
+  Jsont.Object.map ~kind:"Rgb"
+    (fun _typ b g r -> { b; g; r })
+  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.theme.color#rgb" ~enc:(fun _ -> "site.standard.theme.color#rgb")
   |> Jsont.Object.mem "b" Jsont.int ~enc:(fun r -> r.b)
-  |> Jsont.Object.mem "a" Jsont.int ~enc:(fun r -> r.a)
+  |> Jsont.Object.mem "g" Jsont.int ~enc:(fun r -> r.g)
+  |> Jsont.Object.mem "r" Jsont.int ~enc:(fun r -> r.r)
   |> Jsont.Object.finish
 
       end
       module Basic = struct
 type main = {
+  accent : Color.rgb;
+  accent_foreground : Color.rgb;
   background : Color.rgb;
   foreground : Color.rgb;
-  accent : Color.rgb;
-  accent_foreground : Color.rgb;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ background foreground accent accent_foreground -> { background; foreground; accent; accent_foreground })
+    (fun _typ accent accent_foreground background foreground -> { accent; accent_foreground; background; foreground })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.theme.basic" ~enc:(fun _ -> "site.standard.theme.basic")
+  |> Jsont.Object.mem "accent" Color.rgb_jsont ~enc:(fun r -> r.accent)
+  |> 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.mem "accent" Color.rgb_jsont ~enc:(fun r -> r.accent)
-  |> Jsont.Object.mem "accentForeground" Color.rgb_jsont ~enc:(fun r -> r.accent_foreground)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
 type main = {
-  url : string;
+  basic_theme : Theme.Basic.main option;
+  description : string option;
   icon : Atp.Blob_ref.t option;
   name : string;
-  description : string option;
-  basic_theme : Theme.Basic.main option;
   preferences : preferences option;
+  url : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ url icon name description basic_theme preferences -> { url; icon; name; description; basic_theme; preferences })
+    (fun _typ basic_theme description icon name preferences url -> { basic_theme; description; icon; name; preferences; url })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"site.standard.publication" ~enc:(fun _ -> "site.standard.publication")
-  |> Jsont.Object.mem "url" Jsont.string ~enc:(fun r -> r.url)
+  |> Jsont.Object.opt_mem "basicTheme" Theme.Basic.main_jsont ~enc:(fun r -> r.basic_theme)
+  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
   |> Jsont.Object.opt_mem "icon" Atp.Blob_ref.jsont ~enc:(fun r -> r.icon)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "basicTheme" Theme.Basic.main_jsont ~enc:(fun r -> r.basic_theme)
   |> Jsont.Object.opt_mem "preferences" preferences_jsont ~enc:(fun r -> r.preferences)
+  |> Jsont.Object.mem "url" Jsont.string ~enc:(fun r -> r.url)
   |> Jsont.Object.finish
 
     end

lexicons/standard-site/atp_lexicon_standard_site.mli

···
 (** A URI with a content-hash fingerprint. *)
 
 type main = {
-  uri : string;
   cid : string;
+  uri : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** A document record representing a published article, blog post, or other content. Documents can belong to a publication or exist independently. *)
 
 type main = {
-  site : string;  (** Points to a publication record (at://) or a publication url (https://) for loose documents. Avoid trailing slashes. *)
+  bsky_post_ref : Com.Atproto.Repo.StrongRef.main option;  (** Strong reference to a Bluesky post. Useful to keep track of comments off-platform. *)
+  content : Jsont.json option;  (** Open union used to define the record's content. Each entry must specify a $type and may be extended with other lexicons to support additional content formats. *)
+  cover_image : Atp.Blob_ref.t option;  (** Image to used for thumbnail or cover image. Less than 1MB is size. *)
+  description : string option;  (** A brief description or excerpt from the document. *)
   path : string option;  (** Combine with site or publication url to construct a canonical URL to the document. Prepend with a leading slash. *)
+  published_at : string;  (** Timestamp of the documents publish time. *)
+  site : string;  (** Points to a publication record (at://) or a publication url (https://) for loose documents. Avoid trailing slashes. *)
+  tags : string list option;  (** Array of strings used to tag or categorize the document. Avoid prepending tags with hashtags. *)
+  text_content : string option;  (** Plaintext representation of the documents contents. Should not contain markdown or other formatting. *)
   title : string;  (** Title of the document. *)
-  description : string option;  (** A brief description or excerpt from the document. *)
-  cover_image : Atp.Blob_ref.t option;  (** Image to used for thumbnail or cover image. Less than 1MB is size. *)
-  content : Jsont.json option;  (** Open union used to define the record's content. Each entry must specify a $type and may be extended with other lexicons to support additional content formats. *)
-  text_content : string option;  (** Plaintext representation of the documents contents. Should not contain markdown or other formatting. *)
-  bsky_post_ref : Com.Atproto.Repo.StrongRef.main option;  (** Strong reference to a Bluesky post. Useful to keep track of comments off-platform. *)
-  tags : string list option;  (** Array of strings used to tag or categorize the document. Avoid prepending tags with hashtags. *)
-  published_at : string;  (** Timestamp of the documents publish time. *)
   updated_at : string option;  (** Timestamp of the documents last edit. *)
 }
 
···
     module Theme : sig
       module Color : sig
 
-type rgb = {
+type rgba = {
+  a : int;
+  b : int;
+  g : int;
   r : int;
-  g : int;
-  b : int;
 }
 
-(** Jsont codec for {!type:rgb}. *)
-val rgb_jsont : rgb Jsont.t
+(** Jsont codec for {!type:rgba}. *)
+val rgba_jsont : rgba Jsont.t
 
 
-type rgba = {
+type rgb = {
+  b : int;
+  g : int;
   r : int;
-  g : int;
-  b : int;
-  a : int;
 }
 
-(** Jsont codec for {!type:rgba}. *)
-val rgba_jsont : rgba Jsont.t
+(** Jsont codec for {!type:rgb}. *)
+val rgb_jsont : rgb Jsont.t
 
       end
       module Basic : sig
 (** A simplified theme definition for publications, providing basic color customization for content display across different platforms and applications. *)
 
 type main = {
+  accent : Color.rgb;  (** Color used for links and button backgrounds. *)
+  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. *)
-  accent : Color.rgb;  (** Color used for links and button backgrounds. *)
-  accent_foreground : Color.rgb;  (** Color used for button text. *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** A publication record representing a blog, website, or content platform. Publications serve as containers for documents and define the overall branding and settings. *)
 
 type main = {
-  url : string;  (** Base publication url (ex: https://standard.site). The canonical document URL is formed by combining this value with the document path. *)
+  basic_theme : Theme.Basic.main option;  (** Simplified publication theme for tools and apps to utilize when displaying content. *)
+  description : string option;  (** Brief description of the publication. *)
   icon : Atp.Blob_ref.t option;  (** Square image to identify the publication. Should be at least 256x256. *)
   name : string;  (** Name of the publication. *)
-  description : string option;  (** Brief description of the publication. *)
-  basic_theme : Theme.Basic.main option;  (** Simplified publication theme for tools and apps to utilize when displaying content. *)
   preferences : preferences option;  (** Object containing platform specific preferences (with a few shared properties). *)
+  url : string;  (** Base publication url (ex: https://standard.site). The canonical document URL is formed by combining this value with the document path. *)
 }
 
 (** Jsont codec for {!type:main}. *)

lexicons/tangled/atp_lexicon_tangled.ml

···
 
       module Member = struct
 type main = {
-  subject : string;
-  instance : string;
   created_at : string;
+  instance : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject instance created_at -> { subject; instance; created_at })
+    (fun _typ created_at instance subject -> { created_at; instance; subject })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.spindle.member" ~enc:(fun _ -> "sh.tangled.spindle.member")
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "instance" Jsont.string ~enc:(fun r -> r.instance)
   |> Jsont.Object.mem "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "instance" Jsont.string ~enc:(fun r -> r.instance)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
 type individual_email_commit_count = {
-  email : string;
   count : int;
+  email : string;
 }
 
 let individual_email_commit_count_jsont =
   Jsont.Object.map ~kind:"Individual_email_commit_count"
-    (fun _typ email count -> { email; count })
+    (fun _typ count email -> { count; email })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.git.refUpdate#individualEmailCommitCount" ~enc:(fun _ -> "sh.tangled.git.refUpdate#individualEmailCommitCount")
+  |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
   |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
   |> Jsont.Object.finish
 
 type lang_breakdown = {
···
   |> Jsont.Object.finish
 
 type meta = {
+  commit_count : commit_count_breakdown;
   is_default_ref : bool;
   lang_breakdown : lang_breakdown option;
-  commit_count : commit_count_breakdown;
 }
 
 let meta_jsont =
   Jsont.Object.map ~kind:"Meta"
-    (fun _typ is_default_ref lang_breakdown commit_count -> { is_default_ref; lang_breakdown; commit_count })
+    (fun _typ commit_count is_default_ref lang_breakdown -> { commit_count; is_default_ref; lang_breakdown })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.git.refUpdate#meta" ~enc:(fun _ -> "sh.tangled.git.refUpdate#meta")
+  |> Jsont.Object.mem "commitCount" commit_count_breakdown_jsont ~enc:(fun r -> r.commit_count)
   |> Jsont.Object.mem "isDefaultRef" Jsont.bool ~enc:(fun r -> r.is_default_ref)
   |> Jsont.Object.opt_mem "langBreakdown" lang_breakdown_jsont ~enc:(fun r -> r.lang_breakdown)
-  |> Jsont.Object.mem "commitCount" commit_count_breakdown_jsont ~enc:(fun r -> r.commit_count)
   |> Jsont.Object.finish
 
 type main = {
+  committer_did : string;
+  meta : meta;
+  new_sha : string;
+  old_sha : string;
   ref_ : string;
-  committer_did : string;
   repo_did : string;
   repo_name : string;
-  old_sha : string;
-  new_sha : string;
-  meta : meta;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ ref_ committer_did repo_did repo_name old_sha new_sha meta -> { ref_; committer_did; repo_did; repo_name; old_sha; new_sha; meta })
+    (fun _typ committer_did meta new_sha old_sha ref_ repo_did repo_name -> { committer_did; meta; new_sha; old_sha; ref_; repo_did; repo_name })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.git.refUpdate" ~enc:(fun _ -> "sh.tangled.git.refUpdate")
+  |> Jsont.Object.mem "committerDid" Jsont.string ~enc:(fun r -> r.committer_did)
+  |> Jsont.Object.mem "meta" meta_jsont ~enc:(fun r -> r.meta)
+  |> 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.mem "committerDid" Jsont.string ~enc:(fun r -> r.committer_did)
   |> Jsont.Object.mem "repoDid" Jsont.string ~enc:(fun r -> r.repo_did)
   |> Jsont.Object.mem "repoName" Jsont.string ~enc:(fun r -> r.repo_name)
-  |> Jsont.Object.mem "oldSha" Jsont.string ~enc:(fun r -> r.old_sha)
-  |> Jsont.Object.mem "newSha" Jsont.string ~enc:(fun r -> r.new_sha)
-  |> Jsont.Object.mem "meta" meta_jsont ~enc:(fun r -> r.meta)
   |> Jsont.Object.finish
 
       end
···
     module Actor = struct
       module Profile = struct
 type main = {
+  bluesky : bool;
   description : string option;
   links : string list option;
-  stats : string list option;
-  bluesky : bool;
   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 description links stats bluesky location pinned_repositories pronouns -> { description; links; stats; bluesky; location; pinned_repositories; pronouns })
+    (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 "stats" (Jsont.list Jsont.string) ~enc:(fun r -> r.stats)
-  |> Jsont.Object.mem "bluesky" Jsont.bool ~enc:(fun r -> r.bluesky)
   |> 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 = {
-  filename : string;
-  description : string;
+  contents : string;
   created_at : string;
-  contents : string;
+  description : string;
+  filename : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ filename description created_at contents -> { filename; description; created_at; contents })
+    (fun _typ contents created_at description filename -> { contents; created_at; description; filename })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.string" ~enc:(fun _ -> "sh.tangled.string")
-  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
-  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.mem "contents" Jsont.string ~enc:(fun r -> r.contents)
+  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
+  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
   |> Jsont.Object.finish
 
     end
     module Feed = struct
       module Star = struct
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject created_at -> { subject; created_at })
+    (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.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
       end
       module Reaction = struct
 type main = {
-  subject : string;
-  reaction : string;
   created_at : string;
+  reaction : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject reaction created_at -> { subject; reaction; created_at })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "reaction" Jsont.string ~enc:(fun r -> r.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;
+  description : string option;
+  knot : string;
+  labels : string list option;
   name : string;
-  knot : string;
+  source : string option;
   spindle : string option;
-  description : string option;
+  topics : string list option;
   website : string option;
-  topics : string list option;
-  source : string option;
-  labels : string list option;
-  created_at : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ name knot spindle description website topics source labels created_at -> { name; knot; spindle; description; website; topics; source; labels; created_at })
+    (fun _typ created_at description knot labels name source spindle topics website -> { created_at; description; knot; labels; name; source; spindle; topics; website })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo" ~enc:(fun _ -> "sh.tangled.repo")
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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.mem "knot" Jsont.string ~enc:(fun r -> r.knot)
+  |> Jsont.Object.opt_mem "labels" (Jsont.list Jsont.string) ~enc:(fun r -> r.labels)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.opt_mem "source" Jsont.string ~enc:(fun r -> r.source)
   |> Jsont.Object.opt_mem "spindle" Jsont.string ~enc:(fun r -> r.spindle)
-  |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-  |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
   |> Jsont.Object.opt_mem "topics" (Jsont.list Jsont.string) ~enc:(fun r -> r.topics)
-  |> Jsont.Object.opt_mem "source" Jsont.string ~enc:(fun r -> r.source)
-  |> Jsont.Object.opt_mem "labels" (Jsont.list Jsont.string) ~enc:(fun r -> r.labels)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
+  |> Jsont.Object.opt_mem "website" Jsont.string ~enc:(fun r -> r.website)
   |> Jsont.Object.finish
 
       module Artifact = struct
 type main = {
+  artifact : Atp.Blob_ref.t;
+  created_at : string;
   name : string;
   repo : string;
   tag : string;
-  created_at : string;
-  artifact : Atp.Blob_ref.t;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ name repo tag created_at artifact -> { name; repo; tag; created_at; artifact })
+    (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.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 "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
-  |> Jsont.Object.mem "artifact" Atp.Blob_ref.jsont ~enc:(fun r -> r.artifact)
   |> Jsont.Object.finish
 
       end
···
   |> Jsont.Object.finish
 
 type input = {
+  branch : string;
   did : string;
   name : string;
   patch : string;
-  branch : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ did name patch branch -> { did; name; patch; branch })
+    (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 "patch" Jsont.string ~enc:(fun r -> r.patch)
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
   |> Jsont.Object.finish
 
 type output = {
-  is_conflicted : bool;
   conflicts : conflict_info list option;
-  message : string option;
   error : string option;
+  is_conflicted : bool;
+  message : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ is_conflicted conflicts message error -> { is_conflicted; conflicts; message; error })
+    (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.mem "is_conflicted" Jsont.bool ~enc:(fun r -> r.is_conflicted)
   |> 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.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
   |> Jsont.Object.finish
 
       end
       module Tree = struct
 type readme = {
-  filename : string;
   contents : string;
+  filename : string;
 }
 
 let readme_jsont =
   Jsont.Object.map ~kind:"Readme"
-    (fun _typ filename contents -> { filename; contents })
+    (fun _typ contents filename -> { contents; filename })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.tree#readme" ~enc:(fun _ -> "sh.tangled.repo.tree#readme")
-  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
   |> Jsont.Object.mem "contents" Jsont.string ~enc:(fun r -> r.contents)
+  |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
   |> Jsont.Object.finish
 
 type last_commit = {
···
   |> Jsont.Object.finish
 
 type tree_entry = {
+  last_commit : last_commit option;
+  mode : string;
   name : string;
-  mode : string;
   size : int;
-  last_commit : last_commit option;
 }
 
 let tree_entry_jsont =
   Jsont.Object.map ~kind:"Tree_entry"
-    (fun _typ name mode size last_commit -> { name; mode; size; last_commit })
+    (fun _typ last_commit mode name size -> { last_commit; mode; name; size })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.tree#treeEntry" ~enc:(fun _ -> "sh.tangled.repo.tree#treeEntry")
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> Jsont.Object.opt_mem "last_commit" last_commit_jsont ~enc:(fun r -> r.last_commit)
   |> Jsont.Object.mem "mode" Jsont.string ~enc:(fun r -> r.mode)
+  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "size" Jsont.int ~enc:(fun r -> r.size)
-  |> Jsont.Object.opt_mem "last_commit" last_commit_jsont ~enc:(fun r -> r.last_commit)
   |> Jsont.Object.finish
 
 type params = {
-  repo : string;
+  path : string option;
   ref_ : string;
-  path : string option;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ path -> {
+    (fun path ref_ repo -> {
+      path;
+      ref_;
       repo;
-      ref_;
-      path;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
+  |> 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.opt_mem "path" Jsont.string
-       ~enc:(fun r -> r.path)
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
 type output = {
-  ref_ : string;
-  parent : string option;
   dotdot : string option;
+  files : tree_entry list;
+  parent : string option;
   readme : readme option;
-  files : tree_entry list;
+  ref_ : string;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ ref_ parent dotdot readme files -> { ref_; parent; dotdot; readme; files })
+    (fun _typ dotdot files parent readme ref_ -> { dotdot; files; parent; readme; ref_ })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.tree#output" ~enc:(fun _ -> "sh.tangled.repo.tree#output")
-  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.opt_mem "parent" Jsont.string ~enc:(fun r -> r.parent)
   |> Jsont.Object.opt_mem "dotdot" Jsont.string ~enc:(fun r -> r.dotdot)
-  |> Jsont.Object.opt_mem "readme" readme_jsont ~enc:(fun r -> r.readme)
   |> Jsont.Object.mem "files" (Jsont.list tree_entry_jsont) ~enc:(fun r -> r.files)
+  |> Jsont.Object.opt_mem "parent" Jsont.string ~enc:(fun r -> r.parent)
+  |> Jsont.Object.opt_mem "readme" readme_jsont ~enc:(fun r -> r.readme)
+  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
   |> Jsont.Object.finish
 
       end
       module SetDefaultBranch = struct
 type input = {
-  repo : string;
   default_branch : string;
+  repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo default_branch -> { repo; default_branch })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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
···
       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;
-  branch : string;
-  author_name : string option;
-  author_email : string option;
-  commit_body : string option;
-  commit_message : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ did name patch branch author_name author_email commit_body commit_message -> { did; name; patch; branch; author_name; author_email; commit_body; commit_message })
+    (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)
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.opt_mem "authorName" Jsont.string ~enc:(fun r -> r.author_name)
-  |> Jsont.Object.opt_mem "authorEmail" Jsont.string ~enc:(fun r -> r.author_email)
-  |> 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.finish
 
       end
       module Tags = struct
 type params = {
-  repo : string;
+  cursor : string option;
   limit : int option;
-  cursor : string option;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo limit cursor -> {
-      repo;
-      limit;
+    (fun cursor limit repo -> {
       cursor;
+      limit;
+      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.mem "repo" Jsont.string
        ~enc:(fun r -> r.repo)
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.limit)
-  |> Jsont.Object.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
   |> Jsont.Object.finish
 
 type output = unit
···
       end
       module Collaborator = struct
 type main = {
+  created_at : string;
+  repo : string;
   subject : string;
-  repo : string;
-  created_at : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject repo created_at -> { subject; repo; created_at })
+    (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)
-  |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
       end
       module Branches = struct
 type params = {
-  repo : string;
-  limit : int option;
   cursor : string option;
+  limit : int option;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo limit cursor -> {
-      repo;
-      limit;
+    (fun cursor limit repo -> {
       cursor;
+      limit;
+      repo;
     })
-  |> 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.opt_mem "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> Jsont.Object.mem "repo" Jsont.string
+       ~enc:(fun r -> r.repo)
   |> Jsont.Object.finish
 
 type output = unit
···
       end
       module GetDefaultBranch = struct
 type signature = {
-  name : string;
   email : string;
+  name : string;
   when_ : string;
 }
 
 let signature_jsont =
   Jsont.Object.map ~kind:"Signature"
-    (fun _typ name email when_ -> { name; email; when_ })
+    (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 "email" Jsont.string ~enc:(fun r -> r.email)
   |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
   |> Jsont.Object.finish
 
···
   |> Jsont.Object.finish
 
 type output = {
-  name : string;
+  author : signature option;
   hash : string;
+  message : string option;
+  name : string;
   short_hash : string option;
   when_ : string;
-  message : string option;
-  author : signature option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ name hash short_hash when_ message author -> { name; hash; short_hash; when_; message; author })
+    (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.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
   |> Jsont.Object.finish
 
       end
       module Create = struct
 type input = {
-  rkey : string;
   default_branch : string option;
+  rkey : string;
   source : string option;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ rkey default_branch source -> { rkey; default_branch; source })
+    (fun _typ default_branch rkey source -> { default_branch; rkey; source })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.create#input" ~enc:(fun _ -> "sh.tangled.repo.create#input")
-  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
   |> Jsont.Object.opt_mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
+  |> Jsont.Object.mem "rkey" Jsont.string ~enc:(fun r -> r.rkey)
   |> Jsont.Object.opt_mem "source" Jsont.string ~enc:(fun r -> r.source)
   |> Jsont.Object.finish
 
       end
       module ForkStatus = struct
 type input = {
+  branch : string;
   did : string;
+  hidden_ref : string;
   name : string;
   source : string;
-  branch : string;
-  hidden_ref : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ did name source branch hidden_ref -> { did; name; source; branch; hidden_ref })
+    (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 "source" Jsont.string ~enc:(fun r -> r.source)
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
-  |> Jsont.Object.mem "hiddenRef" Jsont.string ~enc:(fun r -> r.hidden_ref)
   |> Jsont.Object.finish
 
 type output = {
···
       end
       module Branch = struct
 type signature = {
+  email : string;
   name : string;
-  email : string;
   when_ : string;
 }
 
 let signature_jsont =
   Jsont.Object.map ~kind:"Signature"
-    (fun _typ name email when_ -> { name; email; when_ })
+    (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 "name" Jsont.string ~enc:(fun r -> r.name)
   |> 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 = {
-  repo : string;
   name : string;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo name -> {
-      repo;
+    (fun name repo -> {
       name;
+      repo;
     })
+  |> 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 "name" Jsont.string
-       ~enc:(fun r -> r.name)
   |> Jsont.Object.finish
 
 type output = {
+  author : signature option;
+  hash : string;
+  is_default : bool option;
+  message : string option;
   name : string;
-  hash : string;
   short_hash : string option;
   when_ : string;
-  message : string option;
-  author : signature option;
-  is_default : bool option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ name hash short_hash when_ message author is_default -> { name; hash; short_hash; when_; message; author; is_default })
+    (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.mem "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
-  |> Jsont.Object.opt_mem "isDefault" Jsont.bool ~enc:(fun r -> r.is_default)
   |> Jsont.Object.finish
 
       end
       module DeleteBranch = struct
 type input = {
-  repo : string;
   branch : string;
+  repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo branch -> { repo; branch })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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 Log = struct
 type params = {
+  cursor : string option;
+  limit : int option;
+  path : string option;
+  ref_ : string;
   repo : string;
-  ref_ : string;
-  path : string option;
-  limit : int option;
-  cursor : string option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ path limit cursor -> {
-      repo;
-      ref_;
+    (fun cursor limit path ref_ repo -> {
+      cursor;
+      limit;
       path;
-      limit;
-      cursor;
+      ref_;
+      repo;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.opt_mem "path" Jsont.string
-       ~enc:(fun r -> r.path)
+  |> 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 "cursor" Jsont.string
-       ~enc:(fun r -> r.cursor)
+  |> 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
···
 
       end
       module Blob = struct
-type signature = {
-  name : string;
-  email : string;
-  when_ : string;
-}
-
-let signature_jsont =
-  Jsont.Object.map ~kind:"Signature"
-    (fun _typ name email when_ -> { name; email; when_ })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.blob#signature" ~enc:(fun _ -> "sh.tangled.repo.blob#signature")
-  |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
-  |> Jsont.Object.mem "when" Jsont.string ~enc:(fun r -> r.when_)
-  |> Jsont.Object.finish
-
 type submodule = {
+  branch : string option;
   name : string;
   url : string;
-  branch : string option;
 }
 
 let submodule_jsont =
   Jsont.Object.map ~kind:"Submodule"
-    (fun _typ name url branch -> { name; url; branch })
+    (fun _typ branch name url -> { branch; name; url })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.blob#submodule" ~enc:(fun _ -> "sh.tangled.repo.blob#submodule")
+  |> Jsont.Object.opt_mem "branch" Jsont.string ~enc:(fun r -> r.branch)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
   |> Jsont.Object.mem "url" Jsont.string ~enc:(fun r -> r.url)
-  |> Jsont.Object.opt_mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.finish
+
+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.blob#signature" ~enc:(fun _ -> "sh.tangled.repo.blob#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 last_commit = {
+  author : signature option;
   hash : string;
-  short_hash : string option;
   message : string;
-  author : signature option;
+  short_hash : string option;
   when_ : string;
 }
 
 let last_commit_jsont =
   Jsont.Object.map ~kind:"Last_commit"
-    (fun _typ hash short_hash message author when_ -> { hash; short_hash; message; author; when_ })
+    (fun _typ author hash message short_hash when_ -> { author; hash; message; short_hash; when_ })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.blob#lastCommit" ~enc:(fun _ -> "sh.tangled.repo.blob#lastCommit")
+  |> 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 "shortHash" Jsont.string ~enc:(fun r -> r.short_hash)
   |> Jsont.Object.mem "message" Jsont.string ~enc:(fun r -> r.message)
-  |> Jsont.Object.opt_mem "author" signature_jsont ~enc:(fun r -> r.author)
+  |> 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
 
 type params = {
-  repo : string;
-  ref_ : string;
   path : string;
   raw : bool option;
+  ref_ : string;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ path raw -> {
-      repo;
-      ref_;
+    (fun path raw ref_ repo -> {
       path;
       raw;
+      ref_;
+      repo;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "path" Jsont.string
        ~enc:(fun r -> r.path)
   |> Jsont.Object.opt_mem "raw" Jsont.bool
        ~enc:(fun r -> r.raw)
+  |> 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 = {
-  ref_ : string;
-  path : string;
   content : string option;
   encoding : string option;
-  size : int option;
   is_binary : bool option;
+  last_commit : last_commit option;
   mime_type : string option;
+  path : string;
+  ref_ : string;
+  size : int option;
   submodule : submodule option;
-  last_commit : last_commit option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ ref_ path content encoding size is_binary mime_type submodule last_commit -> { ref_; path; content; encoding; size; is_binary; mime_type; submodule; last_commit })
+    (fun _typ content encoding is_binary last_commit mime_type path ref_ size submodule -> { content; encoding; is_binary; last_commit; mime_type; path; ref_; size; submodule })
   |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.repo.blob#output" ~enc:(fun _ -> "sh.tangled.repo.blob#output")
-  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
-  |> Jsont.Object.mem "path" Jsont.string ~enc:(fun r -> r.path)
   |> Jsont.Object.opt_mem "content" Jsont.string ~enc:(fun r -> r.content)
   |> Jsont.Object.opt_mem "encoding" Jsont.string ~enc:(fun r -> r.encoding)
-  |> Jsont.Object.opt_mem "size" Jsont.int ~enc:(fun r -> r.size)
   |> Jsont.Object.opt_mem "isBinary" Jsont.bool ~enc:(fun r -> r.is_binary)
+  |> Jsont.Object.opt_mem "lastCommit" last_commit_jsont ~enc:(fun r -> r.last_commit)
   |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun r -> r.mime_type)
+  |> Jsont.Object.mem "path" Jsont.string ~enc:(fun r -> r.path)
+  |> Jsont.Object.mem "ref" Jsont.string ~enc:(fun r -> r.ref_)
+  |> Jsont.Object.opt_mem "size" Jsont.int ~enc:(fun r -> r.size)
   |> Jsont.Object.opt_mem "submodule" submodule_jsont ~enc:(fun r -> r.submodule)
-  |> Jsont.Object.opt_mem "lastCommit" last_commit_jsont ~enc:(fun r -> r.last_commit)
   |> Jsont.Object.finish
 
       end
       module RemoveSecret = struct
 type input = {
-  repo : string;
   key : string;
+  repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo key -> { repo; key })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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
 
       end
       module Languages = struct
 type language = {
+  color : string option;
+  extensions : string list option;
+  file_count : int option;
   name : string;
-  size : int;
   percentage : int;
-  file_count : int option;
-  color : string option;
-  extensions : string list option;
+  size : int;
 }
 
 let language_jsont =
   Jsont.Object.map ~kind:"Language"
-    (fun _typ name size percentage file_count color extensions -> { name; size; percentage; file_count; color; extensions })
+    (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.mem "percentage" Jsont.int ~enc:(fun r -> r.percentage)
-  |> Jsont.Object.opt_mem "fileCount" Jsont.int ~enc:(fun r -> r.file_count)
-  |> 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.finish
 
 type params = {
-  repo : string;
   ref_ : string option;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ -> {
+    (fun ref_ repo -> {
+      ref_;
       repo;
-      ref_;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.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 = {
-  ref_ : string;
   languages : language list;
+  ref_ : string;
+  total_files : int option;
   total_size : int option;
-  total_files : int option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ ref_ languages total_size total_files -> { ref_; languages; total_size; total_files })
+    (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 "ref" Jsont.string ~enc:(fun r -> r.ref_)
   |> Jsont.Object.mem "languages" (Jsont.list language_jsont) ~enc:(fun r -> r.languages)
-  |> Jsont.Object.opt_mem "totalSize" Jsont.int ~enc:(fun r -> r.total_size)
+  |> 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 Diff = struct
 type params = {
-  repo : string;
   ref_ : string;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ -> {
-      repo;
+    (fun ref_ repo -> {
       ref_;
+      repo;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.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
···
       end
       module ForkSync = struct
 type input = {
+  branch : string;
   did : string;
-  source : string;
   name : string;
-  branch : string;
+  source : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ did source name branch -> { did; source; name; branch })
+    (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 "source" Jsont.string ~enc:(fun r -> r.source)
   |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "branch" Jsont.string ~enc:(fun r -> r.branch)
+  |> Jsont.Object.mem "source" Jsont.string ~enc:(fun r -> r.source)
   |> Jsont.Object.finish
 
       end
       module AddSecret = struct
 type input = {
-  repo : string;
   key : string;
+  repo : string;
   value : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo key value -> { repo; key; value })
+    (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 "key" Jsont.string ~enc:(fun r -> r.key)
   |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
···
       end
       module ListSecrets = struct
 type secret = {
-  repo : string;
-  key : string;
   created_at : string;
   created_by : string;
+  key : string;
+  repo : string;
 }
 
 let secret_jsont =
   Jsont.Object.map ~kind:"Secret"
-    (fun _typ repo key created_at created_by -> { repo; key; created_at; created_by })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
   |> 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 = {
···
       end
       module Archive = struct
 type params = {
-  repo : string;
-  ref_ : string;
   format : string option;
   prefix : string option;
+  ref_ : string;
+  repo : string;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun repo ref_ format prefix -> {
-      repo;
-      ref_;
+    (fun format prefix ref_ repo -> {
       format;
       prefix;
+      ref_;
+      repo;
     })
-  |> Jsont.Object.mem "repo" Jsont.string
-       ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "ref" Jsont.string
-       ~enc:(fun r -> r.ref_)
   |> 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
 
 type output = unit
···
       end
       module HiddenRef = struct
 type input = {
-  repo : string;
   fork_ref : string;
   remote_ref : string;
+  repo : string;
 }
 
 let input_jsont =
   Jsont.Object.map ~kind:"Input"
-    (fun _typ repo fork_ref remote_ref -> { repo; fork_ref; remote_ref })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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 = {
-  success : bool;
-  ref_ : string option;
   error : string option;
+  ref_ : string option;
+  success : bool;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ success ref_ error -> { success; ref_; error })
+    (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.mem "success" Jsont.bool ~enc:(fun r -> r.success)
+  |> 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.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
+  |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
   |> Jsont.Object.finish
 
       end
       module Pull = struct
 type target = {
-  repo : string;
   branch : string;
+  repo : string;
 }
 
 let target_jsont =
   Jsont.Object.map ~kind:"Target"
-    (fun _typ repo branch -> { repo; branch })
+    (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 "repo" Jsont.string ~enc:(fun r -> r.repo)
   |> 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
 
 type source = {
   branch : string;
-  sha : string;
   repo : string option;
+  sha : string;
 }
 
 let source_jsont =
   Jsont.Object.map ~kind:"Source"
-    (fun _typ branch sha repo -> { branch; sha; repo })
+    (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.mem "sha" Jsont.string ~enc:(fun r -> r.sha)
   |> 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 = {
-  target : target;
-  title : string;
   body : string option;
-  patch : string option;
-  patch_blob : Atp.Blob_ref.t;
-  source : source 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 target title body patch patch_blob source created_at mentions references -> { target; title; body; patch; patch_blob; source; created_at; mentions; references })
+    (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.mem "target" target_jsont ~enc:(fun r -> r.target)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
   |> 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 "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 "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 = {
-  pull : string;
   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 pull body created_at mentions references -> { pull; body; created_at; mentions; references })
+    (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 "pull" Jsont.string ~enc:(fun r -> r.pull)
   |> 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 Issue = struct
 type main = {
-  repo : string;
-  title : string;
   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 repo title body created_at mentions references -> { repo; title; body; created_at; mentions; references })
+    (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.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
   |> 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 = {
-  issue : string;
   body : string;
   created_at : string;
-  reply_to : string option;
+  issue : string;
   mentions : string list option;
   references : string list option;
+  reply_to : string option;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ issue body created_at reply_to mentions references -> { issue; body; created_at; reply_to; mentions; references })
+    (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 "issue" Jsont.string ~enc:(fun r -> r.issue)
   |> 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 "replyTo" Jsont.string ~enc:(fun r -> r.reply_to)
+  |> 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 Label = struct
       module Definition = struct
 type value_type = {
-  type_ : string;
-  format : string;
   enum : string list option;
+  format : string;
+  type_ : string;
 }
 
 let value_type_jsont =
   Jsont.Object.map ~kind:"Value_type"
-    (fun _typ type_ format enum -> { type_; format; enum })
+    (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.mem "format" Jsont.string ~enc:(fun r -> r.format)
-  |> Jsont.Object.opt_mem "enum" (Jsont.list Jsont.string) ~enc:(fun r -> r.enum)
   |> Jsont.Object.finish
 
 type main = {
-  name : string;
-  value_type : value_type;
-  scope : string list;
   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 name value_type scope color created_at multiple -> { name; value_type; scope; color; created_at; multiple })
+    (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.mem "name" Jsont.string ~enc:(fun r -> r.name)
-  |> Jsont.Object.mem "valueType" value_type_jsont ~enc:(fun r -> r.value_type)
-  |> Jsont.Object.mem "scope" (Jsont.list Jsont.string) ~enc:(fun r -> r.scope)
   |> 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
···
   |> Jsont.Object.finish
 
 type main = {
-  subject : string;
-  performed_at : string;
   add : operand list;
   delete : operand list;
+  performed_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject performed_at add delete -> { subject; performed_at; add; delete })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
-  |> Jsont.Object.mem "performedAt" Jsont.string ~enc:(fun r -> r.performed_at)
   |> 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 Graph = struct
       module Follow = struct
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject created_at -> { subject; created_at })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
   |> 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 Member = struct
 type main = {
-  subject : string;
-  domain : string;
   created_at : string;
+  domain : string;
+  subject : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ subject domain created_at -> { subject; domain; created_at })
+    (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 "subject" Jsont.string ~enc:(fun r -> r.subject)
+  |> 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 "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 ListKeys = struct
 type public_key = {
+  created_at : string;
   did : string;
   key : string;
-  created_at : string;
 }
 
 let public_key_jsont =
   Jsont.Object.map ~kind:"Public_key"
-    (fun _typ did key created_at -> { did; key; created_at })
+    (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.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
 type params = {
-  limit : int option;
   cursor : string option;
+  limit : int option;
 }
 
 let params_jsont =
   Jsont.Object.map ~kind:"Params"
-    (fun limit cursor -> {
-      limit;
+    (fun cursor limit -> {
       cursor;
+      limit;
     })
-  |> Jsont.Object.opt_mem "limit" Jsont.int
-       ~enc:(fun r -> r.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;
-  cursor : string option;
 }
 
 let output_jsont =
   Jsont.Object.map ~kind:"Output"
-    (fun _typ keys cursor -> { keys; cursor })
+    (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.mem "keys" (Jsont.list public_key_jsont) ~enc:(fun r -> r.keys)
   |> 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
···
     end
     module PublicKey = struct
 type main = {
+  created_at : string;
   key : string;
   name : string;
-  created_at : string;
 }
 
 let main_jsont =
   Jsont.Object.map ~kind:"Main"
-    (fun _typ key name created_at -> { key; name; created_at })
+    (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.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
   |> Jsont.Object.finish
 
     end
     module Pipeline = struct
 type trigger_repo = {
-  knot : string;
+  default_branch : string;
   did : string;
+  knot : string;
   repo : string;
-  default_branch : string;
 }
 
 let trigger_repo_jsont =
   Jsont.Object.map ~kind:"Trigger_repo"
-    (fun _typ knot did repo default_branch -> { knot; did; repo; default_branch })
+    (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 "did" Jsont.string ~enc:(fun r -> r.did)
   |> Jsont.Object.mem "repo" Jsont.string ~enc:(fun r -> r.repo)
-  |> Jsont.Object.mem "defaultBranch" Jsont.string ~enc:(fun r -> r.default_branch)
   |> Jsont.Object.finish
 
 type push_trigger_data = {
-  ref_ : string;
   new_sha : string;
   old_sha : string;
+  ref_ : string;
 }
 
 let push_trigger_data_jsont =
   Jsont.Object.map ~kind:"Push_trigger_data"
-    (fun _typ ref_ new_sha old_sha -> { ref_; new_sha; old_sha })
+    (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 "ref" Jsont.string ~enc:(fun r -> r.ref_)
   |> 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;
-  target_branch : string;
   source_sha : string;
-  action : string;
+  target_branch : string;
 }
 
 let pull_request_trigger_data_jsont =
   Jsont.Object.map ~kind:"Pull_request_trigger_data"
-    (fun _typ source_branch target_branch source_sha action -> { source_branch; target_branch; source_sha; action })
+    (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 "targetBranch" Jsont.string ~enc:(fun r -> r.target_branch)
   |> Jsont.Object.mem "sourceSha" Jsont.string ~enc:(fun r -> r.source_sha)
-  |> Jsont.Object.mem "action" Jsont.string ~enc:(fun r -> r.action)
-  |> Jsont.Object.finish
-
-type clone_opts = {
-  skip : bool;
-  depth : int;
-  submodules : bool;
-}
-
-let clone_opts_jsont =
-  Jsont.Object.map ~kind:"Clone_opts"
-    (fun _typ skip depth submodules -> { skip; depth; submodules })
-  |> Jsont.Object.mem "$type" Jsont.string ~dec_absent:"sh.tangled.pipeline#cloneOpts" ~enc:(fun _ -> "sh.tangled.pipeline#cloneOpts")
-  |> Jsont.Object.mem "skip" Jsont.bool ~enc:(fun r -> r.skip)
-  |> Jsont.Object.mem "depth" Jsont.int ~enc:(fun r -> r.depth)
-  |> Jsont.Object.mem "submodules" Jsont.bool ~enc:(fun r -> r.submodules)
+  |> Jsont.Object.mem "targetBranch" Jsont.string ~enc:(fun r -> r.target_branch)
   |> Jsont.Object.finish
 
 type pair = {
···
   |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
   |> Jsont.Object.finish
 
-type manual_trigger_data = {
-  inputs : pair list option;
+type clone_opts = {
+  depth : int;
+  skip : bool;
+  submodules : bool;
 }
 
-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)
+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 = {
-  name : string;
+  clone : clone_opts;
   engine : string;
-  clone : clone_opts;
+  name : string;
   raw : string;
 }
 
 let workflow_jsont =
   Jsont.Object.map ~kind:"Workflow"
-    (fun _typ name engine clone raw -> { name; engine; clone; raw })
+    (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 "name" Jsont.string ~enc:(fun r -> r.name)
+  |> 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 "clone" clone_opts_jsont ~enc:(fun r -> r.clone)
+  |> 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;
-  repo : trigger_repo;
-  push : push_trigger_data option;
-  pull_request : pull_request_trigger_data option;
   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 repo push pull_request manual -> { kind; repo; push; pull_request; manual })
+    (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.opt_mem "push" push_trigger_data_jsont ~enc:(fun r -> r.push)
-  |> Jsont.Object.opt_mem "pullRequest" pull_request_trigger_data_jsont ~enc:(fun r -> r.pull_request)
-  |> Jsont.Object.opt_mem "manual" manual_trigger_data_jsont ~enc:(fun r -> r.manual)
   |> Jsont.Object.finish
 
 type main = {
···
 
       module Status = struct
 type main = {
-  pipeline : string;
-  workflow : string;
-  status : string;
   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 pipeline workflow status created_at error exit_code -> { pipeline; workflow; status; created_at; error; exit_code })
+    (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 "pipeline" Jsont.string ~enc:(fun r -> r.pipeline)
-  |> Jsont.Object.mem "workflow" Jsont.string ~enc:(fun r -> r.workflow)
-  |> Jsont.Object.mem "status" Jsont.string ~enc:(fun r -> r.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 Member : sig
 
 type main = {
-  subject : string;
-  instance : string;  (** spindle instance that the subject is now a member of *)
   created_at : string;
+  instance : string;  (** spindle instance that the subject is now a member of *)
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
 
 type individual_email_commit_count = {
-  email : string;
   count : int;
+  email : string;
 }
 
 (** Jsont codec for {!type:individual_email_commit_count}. *)
···
 
 
 type meta = {
+  commit_count : commit_count_breakdown;
   is_default_ref : bool;
   lang_breakdown : lang_breakdown option;
-  commit_count : commit_count_breakdown;
 }
 
 (** Jsont codec for {!type:meta}. *)
···
 (** An update to a git repository, emitted by knots. *)
 
 type main = {
-  ref_ : string;  (** Ref being updated *)
   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 *)
-  old_sha : string;  (** old SHA of this ref *)
-  new_sha : string;  (** new SHA of this ref *)
-  meta : meta;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 (** 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;
-  stats : string list option;
-  bluesky : bool;  (** Include link to this account on Bluesky. *)
   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}. *)
···
     module String : sig
 
 type main = {
-  filename : string;
+  contents : string;
+  created_at : string;
   description : string;
-  created_at : string;
-  contents : string;
+  filename : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module Star : sig
 
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module Reaction : sig
 
 type main = {
+  created_at : string;
+  reaction : string;
   subject : string;
-  reaction : string;
-  created_at : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
     module Repo : sig
 
 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 *)
-  knot : string;  (** knot where the repo was created *)
+  source : string option;  (** source of the repo *)
   spindle : string option;  (** CI runner to send jobs to and receive results from *)
-  description : string option;
-  website : string option;  (** Any URI related to the repo *)
   topics : string list option;  (** Topics related to the repo *)
-  source : string option;  (** source of the repo *)
-  labels : string list option;  (** List of labels that this repo subscribes to *)
-  created_at : string;
+  website : string option;  (** Any URI related to the repo *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module Artifact : 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) *)
-  created_at : string;  (** time of creation of this artifact *)
-  artifact : Atp.Blob_ref.t;  (** the artifact *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
 
 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 *)
-  branch : string;  (** Target branch to merge into *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
-  is_conflicted : bool;  (** Whether the merge has conflicts *)
   conflicts : conflict_info list option;  (** List of files with merge conflicts *)
-  message : string option;  (** Additional message about the merge check *)
   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:output}. *)
···
       module Tree : sig
 
 type readme = {
-  filename : string;  (** Name of the readme file *)
   contents : string;  (** Contents of the readme file *)
+  filename : string;  (** Name of the readme file *)
 }
 
 (** Jsont codec for {!type:readme}. *)
···
 
 
 type tree_entry = {
+  last_commit : last_commit option;
+  mode : string;  (** File mode *)
   name : string;  (** Relative file or directory name *)
-  mode : string;  (** File mode *)
   size : int;  (** File size in bytes *)
-  last_commit : last_commit option;
 }
 
 (** Jsont codec for {!type:tree_entry}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   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:params}. *)
···
 
 
 type output = {
-  ref_ : string;  (** The git reference used *)
+  dotdot : string option;  (** Parent directory path *)
+  files : tree_entry list;
   parent : string option;  (** The parent path in the tree *)
-  dotdot : string option;  (** Parent directory path *)
   readme : readme option;  (** Readme for this file tree *)
-  files : tree_entry list;
+  ref_ : string;  (** The git reference used *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 type input = {
-  repo : string;
   default_branch : string;
+  repo : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type input = {
-  did : string;  (** DID of the repository owner *)
-  name : string;  (** Name of the repository *)
-  patch : string;  (** Patch content to merge *)
-  branch : string;  (** Target branch to merge into *)
+  author_email : string option;  (** Author email for the merge commit *)
   author_name : string option;  (** Author name for the merge commit *)
-  author_email : string option;  (** Author email 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:input}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+  cursor : string option;  (** Pagination cursor *)
   limit : int option;  (** Maximum number of tags to return *)
-  cursor : string option;  (** Pagination cursor *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
       module Collaborator : sig
 
 type main = {
-  subject : string;
-  repo : string;  (** repo to add this user to *)
   created_at : string;
+  repo : string;  (** repo to add this user to *)
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
+  cursor : string option;  (** Pagination cursor *)
   limit : int option;  (** Maximum number of branches to return *)
-  cursor : string option;  (** Pagination cursor *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
       module GetDefaultBranch : sig
 
 type signature = {
-  name : string;  (** Author name *)
   email : string;  (** Author email *)
+  name : string;  (** Author name *)
   when_ : string;  (** Author timestamp *)
 }
 
···
 
 
 type output = {
+  author : signature option;
+  hash : string;  (** Latest commit hash on default branch *)
+  message : string option;  (** Latest commit message *)
   name : string;  (** Default branch name *)
-  hash : string;  (** Latest commit hash on default branch *)
   short_hash : string option;  (** Short commit hash *)
   when_ : string;  (** Timestamp of latest commit *)
-  message : string option;  (** Latest commit message *)
-  author : signature option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 type input = {
-  rkey : string;  (** Rkey of the repository record *)
   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 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 *)
-  branch : string;  (** Branch to check status for *)
-  hidden_ref : string;  (** Hidden ref to use for comparison *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
       module Branch : sig
 
 type signature = {
-  name : string;  (** Author name *)
   email : string;  (** Author email *)
+  name : string;  (** Author name *)
   when_ : string;  (** Author timestamp *)
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
+  name : string;  (** Branch name to get information for *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  name : string;  (** Branch name to get information for *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  name : string;  (** Branch name *)
+  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 *)
-  message : string option;  (** Latest commit message *)
-  author : signature option;
-  is_default : bool option;  (** Whether this is the default branch *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 type input = {
-  repo : string;
   branch : string;
+  repo : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
-  path : string option;  (** Path to filter commits by *)
+  cursor : string option;  (** Pagination cursor (commit SHA) *)
   limit : int option;  (** Maximum number of commits to return *)
-  cursor : string option;  (** Pagination cursor (commit SHA) *)
+  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:params}. *)
···
       end
       module Blob : sig
 
+type submodule = {
+  branch : string option;  (** Branch to track in the submodule *)
+  name : string;  (** Submodule name *)
+  url : string;  (** Submodule repository URL *)
+}
+
+(** Jsont codec for {!type:submodule}. *)
+val submodule_jsont : submodule Jsont.t
+
+
 type signature = {
-  name : string;  (** Author name *)
   email : string;  (** Author email *)
+  name : string;  (** Author name *)
   when_ : string;  (** Author timestamp *)
 }
 
···
 val signature_jsont : signature Jsont.t
 
 
-type submodule = {
-  name : string;  (** Submodule name *)
-  url : string;  (** Submodule repository URL *)
-  branch : string option;  (** Branch to track in the submodule *)
-}
-
-(** Jsont codec for {!type:submodule}. *)
-val submodule_jsont : submodule Jsont.t
-
-
 type last_commit = {
+  author : signature option;
   hash : string;  (** Commit hash *)
-  short_hash : string option;  (** Short commit hash *)
   message : string;  (** Commit message *)
-  author : signature option;
+  short_hash : string option;  (** Short commit hash *)
   when_ : string;  (** Commit timestamp *)
 }
 
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   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' *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  ref_ : string;  (** The git reference used *)
-  path : string;  (** The file path *)
   content : string option;  (** File content (base64 encoded for binary files) *)
   encoding : string option;  (** Content encoding *)
-  size : int option;  (** File size in bytes *)
   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 *)
-  last_commit : last_commit option;
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 
 type input = {
+  key : string;
   repo : string;
-  key : string;
 }
 
 (** Jsont codec for {!type:input}. *)
···
       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) *)
-  percentage : int;  (** Percentage of total codebase (0-100) *)
-  file_count : int option;  (** Number of files in this language *)
-  color : string option;  (** Hex color code for this language *)
-  extensions : string list option;  (** File extensions associated with this language *)
 }
 
 (** Jsont codec for {!type:language}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
+  ref_ : string option;  (** Git reference (branch, tag, or commit SHA) *)
   repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  ref_ : string option;  (** Git reference (branch, tag, or commit SHA) *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  ref_ : string;  (** The git reference used *)
   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 *)
-  total_files : int option;  (** Total number of files analyzed *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
   ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
+  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type input = {
+  branch : string;  (** Branch to sync *)
   did : string;  (** DID of the fork owner *)
-  source : string;  (** AT-URI of the source repository *)
   name : string;  (** Name of the forked repository *)
-  branch : string;  (** Branch to sync *)
+  source : string;  (** AT-URI of the source repository *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type input = {
-  repo : string;
   key : string;
+  repo : string;
   value : string;
 }
 
···
       module ListSecrets : sig
 
 type secret = {
-  repo : string;
-  key : string;
   created_at : string;
   created_by : string;
+  key : string;
+  repo : string;
 }
 
 (** Jsont codec for {!type:secret}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  repo : string;  (** Repository identifier in format 'did:plc:.../repoName' *)
-  ref_ : string;  (** Git reference (branch, tag, or commit SHA) *)
   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}. *)
···
 
 
 type input = {
-  repo : string;  (** AT-URI of the repository *)
   fork_ref : string;  (** Fork reference name *)
   remote_ref : string;  (** Remote reference name *)
+  repo : string;  (** AT-URI of the repository *)
 }
 
 (** Jsont codec for {!type:input}. *)
···
 
 
 type output = {
-  success : bool;  (** Whether the hidden ref was created successfully *)
+  error : string option;  (** Error message if creation failed *)
   ref_ : string option;  (** The created hidden ref name *)
-  error : string option;  (** Error message if creation failed *)
+  success : bool;  (** Whether the hidden ref was created successfully *)
 }
 
 (** Jsont codec for {!type:output}. *)
···
       module Pull : sig
 
 type target = {
-  repo : string;
   branch : string;
+  repo : string;
 }
 
 (** Jsont codec for {!type:target}. *)
···
 
 type source = {
   branch : string;
-  sha : string;
   repo : string option;
+  sha : string;
 }
 
 (** Jsont codec for {!type:source}. *)
···
 
 
 type main = {
-  target : target;
-  title : string;
   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;
-  created_at : string;
-  mentions : string list option;
-  references : string list option;
+  target : target;
+  title : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
         module Comment : sig
 
 type main = {
-  pull : string;
   body : string;
   created_at : string;
   mentions : string list option;
+  pull : string;
   references : string list option;
 }
 
···
       module Issue : sig
 
 type main = {
-  repo : string;
-  title : string;
   body : string option;
   created_at : string;
   mentions : string list option;
   references : string list option;
+  repo : string;
+  title : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
         module Comment : sig
 
 type main = {
-  issue : string;
   body : string;
   created_at : string;
-  reply_to : string option;
+  issue : string;
   mentions : string list option;
   references : string list option;
+  reply_to : string option;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module Definition : sig
 
 type value_type = {
-  type_ : string;  (** The concrete type of this label's value. *)
-  format : string;  (** An optional constraint that can be applied on string concrete types. *)
   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}. *)
···
 
 
 type main = {
-  name : string;  (** The display name of this label. *)
-  value_type : value_type;  (** The type definition of this label. Appviews may allow sorting for certain types. *)
-  scope : string list;  (** The areas of the repo this label may apply to, eg.: sh.tangled.repo.issue. Appviews may choose to respect this. *)
   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:main}. *)
···
 
 
 type main = {
-  subject : string;  (** The subject (task, pull or discussion) of this label. Appviews may apply a `scope` check and refuse this op. *)
-  performed_at : string;
   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:main}. *)
···
       module Follow : sig
 
 type main = {
-  subject : string;
   created_at : string;
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       module Member : sig
 
 type main = {
-  subject : string;
+  created_at : string;
   domain : string;  (** domain that this member now belongs to *)
-  created_at : string;
+  subject : string;
 }
 
 (** Jsont codec for {!type:main}. *)
···
       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 *)
-  created_at : string;  (** Key upload timestamp *)
 }
 
 (** Jsont codec for {!type:public_key}. *)
···
 
 (** Query/procedure parameters. *)
 type params = {
-  limit : int option;  (** Maximum number of keys to return *)
   cursor : string option;  (** Pagination cursor *)
+  limit : int option;  (** Maximum number of keys to return *)
 }
 
 (** Jsont codec for {!type:params}. *)
···
 
 
 type output = {
-  keys : public_key list;
   cursor : string option;  (** Pagination cursor for next page *)
+  keys : public_key list;
 }
 
 (** Jsont codec for {!type:output}. *)
···
     module PublicKey : sig
 
 type main = {
+  created_at : string;  (** key upload timestamp *)
   key : string;  (** public key contents *)
   name : string;  (** human-readable name for this key *)
-  created_at : string;  (** key upload timestamp *)
 }
 
 (** Jsont codec for {!type:main}. *)
···
     module Pipeline : sig
 
 type trigger_repo = {
-  knot : string;
+  default_branch : string;
   did : string;
+  knot : string;
   repo : string;
-  default_branch : string;
 }
 
 (** Jsont codec for {!type:trigger_repo}. *)
···
 
 
 type push_trigger_data = {
-  ref_ : string;
   new_sha : string;
   old_sha : string;
+  ref_ : string;
 }
 
 (** Jsont codec for {!type:push_trigger_data}. *)
···
 
 
 type pull_request_trigger_data = {
+  action : string;
   source_branch : string;
-  target_branch : string;
   source_sha : string;
-  action : string;
+  target_branch : string;
 }
 
 (** Jsont codec for {!type:pull_request_trigger_data}. *)
 val pull_request_trigger_data_jsont : pull_request_trigger_data Jsont.t
 
 
-type clone_opts = {
-  skip : bool;
-  depth : int;
-  submodules : bool;
-}
-
-(** Jsont codec for {!type:clone_opts}. *)
-val clone_opts_jsont : clone_opts Jsont.t
-
-
 type pair = {
   key : string;
   value : string;
···
 val pair_jsont : pair Jsont.t
 
 
-type manual_trigger_data = {
-  inputs : pair list option;
+type clone_opts = {
+  depth : int;
+  skip : bool;
+  submodules : bool;
 }
 
-(** Jsont codec for {!type:manual_trigger_data}. *)
-val manual_trigger_data_jsont : manual_trigger_data Jsont.t
+(** Jsont codec for {!type:clone_opts}. *)
+val clone_opts_jsont : clone_opts Jsont.t
 
 
 type workflow = {
-  name : string;
-  engine : string;
   clone : clone_opts;
+  engine : string;
+  name : string;
   raw : string;
 }
 
···
 val workflow_jsont : workflow Jsont.t
 
 
+type manual_trigger_data = {
+  inputs : pair list option;
+}
+
+(** Jsont codec for {!type:manual_trigger_data}. *)
+val manual_trigger_data_jsont : manual_trigger_data 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;
-  push : push_trigger_data option;
-  pull_request : pull_request_trigger_data option;
-  manual : manual_trigger_data option;
 }
 
 (** Jsont codec for {!type:trigger_metadata}. *)
···
       module Status : sig
 
 type main = {
-  pipeline : string;  (** ATURI of the pipeline *)
-  workflow : string;  (** name of the workflow within this pipeline *)
-  status : string;  (** status of the workflow *)
   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:main}. *)

xrpc/xrpc.mli

···
     The library provides:
     - {!Client}: Low-level XRPC operations (query, procedure, blob upload)
     - {!Credential}: Session management with automatic token refresh
-    - {!Error}: Structured error types wrapped as Eio exceptions
+    - {!module:Error}: Structured error types wrapped as Eio exceptions
     - {!Jwt}: JWT payload decoding for token expiry checking
     - {!Types}: Core data types (session, error payload, etc.)
 
···
 (** {1 Type Aliases} *)
 
 type client = Xrpc_client.t
-(** Alias for {!Xrpc_client.t}. *)
+(** Alias for [Xrpc_client.t]. *)
 
 type session = Xrpc_types.session
-(** Alias for {!Xrpc_types.session}. *)
+(** Alias for [Xrpc_types.session]. *)
 
 type error = Xrpc_error.error
-(** Alias for {!Xrpc_error.error}. *)
+(** Alias for [Xrpc_error.error]. *)

xrpc/xrpc_client.mli

···
     @param params Query parameters as key-value pairs
     @param decoder jsont codec for decoding the response
 
-    @raise Eio.Io with {!Xrpc_error.E} on failure *)
+    @raise Eio.Io with [Xrpc_error.E] on failure *)
 
 val procedure :
   t ->
···
     @param input_data Optional request body data
     @param decoder jsont codec for decoding the response
 
-    @raise Eio.Io with {!Xrpc_error.E} on failure *)
+    @raise Eio.Io with [Xrpc_error.E] on failure *)
 
 val procedure_blob :
   t ->
···
     @param blob Raw binary data to upload
     @param content_type MIME type of the blob (e.g., ["image/jpeg"])
 
-    @raise Eio.Io with {!Xrpc_error.E} on failure *)
+    @raise Eio.Io with [Xrpc_error.E] on failure *)
 
 (** {1 Raw Binary Operations} *)
 
···
     Returns [(body, content_type)]. Used for endpoints that return binary data
     like [com.atproto.sync.getBlob].
 
-    @raise Eio.Io with {!Xrpc_error.E} on failure *)
+    @raise Eio.Io with [Xrpc_error.E] on failure *)
 
 val procedure_bytes :
   t ->
···
 
     Returns [Some (body, content_type)] or [None] for 204 No Content.
 
-    @raise Eio.Io with {!Xrpc_error.E} on failure *)
+    @raise Eio.Io with [Xrpc_error.E] on failure *)

xrpc/xrpc_cred.mli

···
     @param password Account password or app password
     @param auth_factor_token Optional 2FA token if required
 
-    @raise Eio.Io with {!Xrpc_error.E} on authentication failure *)
+    @raise Eio.Io with [Xrpc_error.E] on authentication failure *)
 
 val login_client :
   t ->
···
     Returns a new client with auto-refresh enabled. The original client is
     updated with the session but doesn't have the refresh interceptor.
 
-    @raise Eio.Io with {!Xrpc_error.E} on authentication failure *)
+    @raise Eio.Io with [Xrpc_error.E] on authentication failure *)
 
 val resume : t -> session:Xrpc_types.session -> unit -> Xrpc_client.t
 (** [resume cred ~session ()] resumes from a stored session.
···
     Returns a client with automatic token refresh. If the access token is
     expired but refresh token is valid, a refresh is attempted immediately.
 
-    @raise Eio.Io with {!Xrpc_error.E} if the refresh token is also expired *)
+    @raise Eio.Io with [Xrpc_error.E] if the refresh token is also expired *)
 
 val logout : t -> unit
 (** [logout cred] logs out and clears the session.

xrpc/xrpc_types.mli

···
 
     {2 Session}
 
-    The {!session} type represents an authenticated user session. Sessions
+    The {!type:session} type represents an authenticated user session. Sessions
     contain JWT tokens for authentication and metadata about the user.
 
     {2 Error Payload}