reorg around a single Jmap module

bin/fastmail_list.ml

···
 
 open Lwt.Syntax
 open Jmap
-open Jmap_mail
+open Jmap.Mail
 open Cmdliner
-module Mail = Jmap_mail.Types
+module Mail = Jmap.Proto.Types
 
 (** Prints the email details *)
 let print_email ~show_labels (email : Mail.email) =
···
   (* Format labels/keywords if requested *)
   let labels_str = 
     if show_labels then
-      let formatted = Jmap_mail.Types.format_email_keywords email.keywords in
+      let formatted = Jmap.Proto.Types.format_email_keywords email.keywords in
       if formatted <> "" then
         " [" ^ formatted ^ "]"
       else
···
   Printf.printf "=====================\n";
   
   (* Step 1: Get all mailboxes *)
-  let* mailboxes_result = Jmap_mail.get_mailboxes conn ~account_id in
+  let* mailboxes_result = Jmap.Proto.get_mailboxes conn ~account_id in
   match mailboxes_result with
   | Error err ->
       Printf.printf "Error getting mailboxes: %s\n" (Api.string_of_error err);
···
           Printf.printf "Using mailbox: %s\n" first_mailbox.Mail.name;
           
           (* Step 3: Get emails from the selected mailbox *)
-          let* emails_result = Jmap_mail.get_messages_in_mailbox
+          let* emails_result = Jmap.Proto.get_messages_in_mailbox
             conn
             ~account_id
             ~mailbox_id:first_mailbox.Mail.id
···
                 (List.length emails);
                 
               (* Display some basic information about the emails *)
-              List.iteri (fun i (email:Jmap_mail.Types.email) ->
+              List.iteri (fun i (email:Jmap.Proto.Types.email) ->
                 let subject = Option.value ~default:"<no subject>" email.Mail.subject in
                 Printf.printf "  %d. %s\n" (i + 1) subject
               ) emails;
···
       | Ok conn ->
           (* Get the primary account ID *)
           let primary_account_id = 
-            let mail_capability = Jmap_mail.Capability.to_string Jmap_mail.Capability.Mail in
+            let mail_capability = Jmap.Proto.Capability.to_string Jmap.Proto.Capability.Mail in
             match List.assoc_opt mail_capability conn.session.primary_accounts with
             | Some id -> id
             | None -> 
···
                     if sender_filter <> "" then begin
                       Printf.printf "Filtering by sender: %s\n" sender_filter;
                       List.filter (fun email -> 
-                        Jmap_mail.email_matches_sender email sender_filter
+                        Jmap.Proto.email_matches_sender email sender_filter
                       ) filtered_by_unread
                     end else
                       filtered_by_unread

bin/fastmail_send.ml

···
       (* Initialize JMAP connection *)
       let fastmail_uri = "https://api.fastmail.com/jmap/session" in
       Lwt_main.run begin
-        let* conn_result = Jmap_mail.login_with_token ~uri:fastmail_uri ~api_token:token in
+        let* conn_result = Jmap.Proto.login_with_token ~uri:fastmail_uri ~api_token:token in
         match conn_result with
         | Error err ->
             let msg = Jmap.Api.string_of_error err in
···
               | Some email -> Lwt.return_ok email
               | None -> 
                   (* Get first available identity *)
-                  let* identities_result = Jmap_mail.get_identities conn ~account_id in
+                  let* identities_result = Jmap.Proto.get_identities conn ~account_id in
                   match identities_result with
                   | Ok [] -> 
                       log_error "No identities found for account";
···
                   (String.concat ", " to_addresses);
                 
                 let* submission_result = 
-                  Jmap_mail.create_and_submit_email 
+                  Jmap.Proto.create_and_submit_email 
                     conn 
                     ~account_id 
                     ~from:from_email
···
                     log_success "Email sent successfully (Submission ID: %s)" submission_id;
                     (* Wait briefly then check submission status *)
                     let* () = Lwt_unix.sleep 1.0 in
-                    let* status_result = Jmap_mail.get_submission_status 
+                    let* status_result = Jmap.Proto.get_submission_status 
                         conn 
                         ~account_id 
                         ~submission_id
···
                     
                     (match status_result with
                     | Ok status ->
-                        let status_text = match status.Jmap_mail.Types.undo_status with
+                        let status_text = match status.Jmap.Proto.Types.undo_status with
                           | Some `pending -> "Pending"
                           | Some `final -> "Final (delivered)"
                           | Some `canceled -> "Canceled"
···
                         in
                         log_info "Submission status: %s" status_text;
                         
-                        (match status.Jmap_mail.Types.delivery_status with
+                        (match status.Jmap.Proto.Types.delivery_status with
                         | Some statuses ->
                             List.iter (fun (email, status) ->
-                              let delivery = match status.Jmap_mail.Types.delivered with
+                              let delivery = match status.Jmap.Proto.Types.delivered with
                                 | Some "yes" -> "Delivered"
                                 | Some "no" -> "Failed"
                                 | Some "queued" -> "Queued"

bin/jmap.ml

···
   if String.length s <= max_len then s
   else String.sub s 0 (max_len - 3) ^ "..."
 
-let format_email_address (addr : Jmap_mail.Email_address.t) =
+let format_email_address (addr : Jmap.Proto.Email_address.t) =
   match addr.name with
   | Some name -> Printf.sprintf "%s <%s>" name addr.email
   | None -> addr.email
···
     ) session.capabilities;
     Fmt.pr "@,  %a@," Fmt.(styled `Bold string) "Accounts:";
     List.iter (fun (id, acct) ->
-      let acct : Jmap_proto.Session.Account.t = acct in
+      let acct : Jmap.Proto.Session.Account.t = acct in
       Fmt.pr "    %a: %s (personal=%b, read_only=%b)@,"
-        Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string id)
+        Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string id)
         acct.name acct.is_personal acct.is_read_only
     ) session.accounts;
     Fmt.pr "@,  %a@," Fmt.(styled `Bold string) "Primary Accounts:";
     List.iter (fun (cap, id) ->
-      Fmt.pr "    %s: %s@," cap (Jmap_proto.Id.to_string id)
+      Fmt.pr "    %s: %s@," cap (Jmap.Proto.Id.to_string id)
     ) session.primary_accounts;
     Fmt.pr "@]@."
   in
···
     let client = Jmap_eio.Cli.create_client ~sw env cfg in
     let account_id = Jmap_eio.Cli.get_account_id cfg client in
 
-    Jmap_eio.Cli.debug cfg "Fetching mailboxes for account %s" (Jmap_proto.Id.to_string account_id);
+    Jmap_eio.Cli.debug cfg "Fetching mailboxes for account %s" (Jmap.Proto.Id.to_string account_id);
 
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
         [mailbox_get ~call_id:"m1" ~account_id ()]
     ) in
 
···
               Fmt.(styled `Bold string) "Mailboxes"
               result.state;
             (* Sort by sort_order then name *)
-            let sorted = List.sort (fun (a : Jmap_mail.Mailbox.t) (b : Jmap_mail.Mailbox.t) ->
+            let sorted = List.sort (fun (a : Jmap.Proto.Mailbox.t) (b : Jmap.Proto.Mailbox.t) ->
               let cmp = Int64.compare a.sort_order b.sort_order in
               if cmp <> 0 then cmp else String.compare a.name b.name
             ) result.list in
-            List.iter (fun (mbox : Jmap_mail.Mailbox.t) ->
+            List.iter (fun (mbox : Jmap.Proto.Mailbox.t) ->
               let role_str = match mbox.role with
-                | Some role -> Printf.sprintf " [%s]" (Jmap_mail.Mailbox.role_to_string role)
+                | Some role -> Printf.sprintf " [%s]" (Jmap.Proto.Mailbox.role_to_string role)
                 | None -> ""
               in
               Fmt.pr "  %a %s%a  (%Ld total, %Ld unread)@,"
-                Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string mbox.id)
+                Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string mbox.id)
                 mbox.name
                 Fmt.(styled `Yellow string) role_str
                 mbox.total_emails mbox.unread_emails
···
     (* Build filter if mailbox specified *)
     let filter = match mailbox_id_str with
       | Some id_str ->
-          let mailbox_id = Jmap_proto.Id.of_string_exn id_str in
-          let cond : Jmap_mail.Email.Filter_condition.t = {
+          let mailbox_id = Jmap.Proto.Id.of_string_exn id_str in
+          let cond : Jmap.Proto.Email.Filter_condition.t = {
             in_mailbox = Some mailbox_id;
             in_mailbox_other_than = None;
             before = None; after = None;
···
             cc = None; bcc = None; subject = None;
             body = None; header = None;
           } in
-          Some (Jmap_proto.Filter.Condition cond)
+          Some (Jmap.Proto.Filter.Condition cond)
       | None -> None
     in
 
-    let sort = [Jmap_proto.Filter.comparator ~is_ascending:false "receivedAt"] in
+    let sort = [Jmap.Proto.Filter.comparator ~is_ascending:false "receivedAt"] in
     let query_inv = Jmap_eio.Client.Build.email_query
       ~call_id:"q1"
       ~account_id
···
 
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
         [query_inv]
     ) in
 
···
               in
               let req2 = Jmap_eio.Client.Build.(
                 make_request
-                  ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+                  ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
                   [get_inv]
               ) in
 
···
                         (match query_result.total with
                          | Some n -> Int64.to_string n
                          | None -> "?");
-                      List.iter (fun (email : Jmap_mail.Email.t) ->
+                      List.iter (fun (email : Jmap.Proto.Email.t) ->
                         let from_str = match email.from with
                           | Some addrs -> format_email_addresses addrs
                           | None -> "(unknown)"
···
                         let flags = format_keywords email.keywords in
                         let flag_str = if flags = "" then "" else " [" ^ flags ^ "]" in
                         Fmt.pr "  %a %s@,"
-                          Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string email.id)
+                          Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string email.id)
                           (ptime_to_string email.received_at);
                         Fmt.pr "    From: %s@," (truncate_string 60 from_str);
                         Fmt.pr "    Subject: %a%s@,"
···
     Jmap_eio.Cli.debug cfg "Searching for: %s" query;
 
     (* Build text filter *)
-    let cond : Jmap_mail.Email.Filter_condition.t = {
+    let cond : Jmap.Proto.Email.Filter_condition.t = {
       in_mailbox = None; in_mailbox_other_than = None;
       before = None; after = None;
       min_size = None; max_size = None;
···
       cc = None; bcc = None; subject = None;
       body = None; header = None;
     } in
-    let filter = Jmap_proto.Filter.Condition cond in
+    let filter = Jmap.Proto.Filter.Condition cond in
 
-    let sort = [Jmap_proto.Filter.comparator ~is_ascending:false "receivedAt"] in
+    let sort = [Jmap.Proto.Filter.comparator ~is_ascending:false "receivedAt"] in
     let query_inv = Jmap_eio.Client.Build.email_query
       ~call_id:"q1"
       ~account_id
···
 
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
         [query_inv]
     ) in
 
···
               in
               let req2 = Jmap_eio.Client.Build.(
                 make_request
-                  ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+                  ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
                   [get_inv]
               ) in
 
···
                         Fmt.(styled `Bold string) "Search results"
                         query
                         (List.length get_result.list);
-                      List.iter (fun (email : Jmap_mail.Email.t) ->
+                      List.iter (fun (email : Jmap.Proto.Email.t) ->
                         let from_str = match email.from with
                           | Some addrs -> format_email_addresses addrs
                           | None -> "(unknown)"
                         in
                         let subject = Option.value email.subject ~default:"(no subject)" in
                         Fmt.pr "  %a %s@,"
-                          Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string email.id)
+                          Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string email.id)
                           (ptime_to_string email.received_at);
                         Fmt.pr "    From: %s@," (truncate_string 60 from_str);
                         Fmt.pr "    Subject: %a@,"
···
     Jmap_eio.Cli.debug cfg "Fetching %d most recent emails" limit;
 
     (* Query for recent emails *)
-    let sort = [Jmap_proto.Filter.comparator ~is_ascending:false "receivedAt"] in
+    let sort = [Jmap.Proto.Filter.comparator ~is_ascending:false "receivedAt"] in
     let query_inv = Jmap_eio.Client.Build.email_query
       ~call_id:"q1"
       ~account_id
···
 
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
         [query_inv]
     ) in
 
···
               in
               let req2 = Jmap_eio.Client.Build.(
                 make_request
-                  ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+                  ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
                   [get_inv]
               ) in
 
···
                       (* Output based on format *)
                       match format with
                       | `Compact ->
-                          List.iter (fun (email : Jmap_mail.Email.t) ->
+                          List.iter (fun (email : Jmap.Proto.Email.t) ->
                             let from_str = match email.from with
                               | Some (addr :: _) ->
                                   Option.value addr.name ~default:addr.email
···
                             let subject = Option.value email.subject ~default:"(no subject)" in
                             let flags = format_keywords email.keywords in
                             Printf.printf "%s\t%s\t%s\t%s\t%s\n"
-                              (Jmap_proto.Id.to_string email.id)
+                              (Jmap.Proto.Id.to_string email.id)
                               (ptime_to_string email.received_at)
                               (truncate_string 20 from_str)
                               (truncate_string 50 subject)
···
                           Fmt.pr "%-12s  %-19s  %-20s  %-40s  %s@,"
                             "ID" "Date" "From" "Subject" "Flags";
                           Fmt.pr "%s@," (String.make 110 '-');
-                          List.iter (fun (email : Jmap_mail.Email.t) ->
+                          List.iter (fun (email : Jmap.Proto.Email.t) ->
                             let from_str = match email.from with
                               | Some (addr :: _) ->
                                   Option.value addr.name ~default:addr.email
···
                             let subject = Option.value email.subject ~default:"(no subject)" in
                             let flags = format_keywords email.keywords in
                             let id_short =
-                              let id = Jmap_proto.Id.to_string email.id in
+                              let id = Jmap.Proto.Id.to_string email.id in
                               if String.length id > 12 then String.sub id 0 12 else id
                             in
                             Fmt.pr "%-12s  %s  %-20s  %-40s  %s@,"
···
                           Fmt.pr "@[<v>%a (%d emails)@,@,"
                             Fmt.(styled `Bold string) "Recent Emails"
                             (List.length get_result.list);
-                          List.iteri (fun i (email : Jmap_mail.Email.t) ->
+                          List.iteri (fun i (email : Jmap.Proto.Email.t) ->
                             let from_str = match email.from with
                               | Some addrs -> format_email_addresses addrs
                               | None -> "(unknown)"
···
                               Fmt.(styled `Bold string) "---"
                               (i + 1) (List.length get_result.list);
                             Fmt.pr "ID:       %a@,"
-                              Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string email.id);
-                            Fmt.pr "Thread:   %s@," (Jmap_proto.Id.to_string email.thread_id);
+                              Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string email.id);
+                            Fmt.pr "Thread:   %s@," (Jmap.Proto.Id.to_string email.thread_id);
                             Fmt.pr "Date:     %s@," (ptime_to_string email.received_at);
                             Fmt.pr "From:     %s@," from_str;
                             if to_str <> "" then Fmt.pr "To:       %s@," to_str;
···
     let client = Jmap_eio.Cli.create_client ~sw env cfg in
     let account_id = Jmap_eio.Cli.get_account_id cfg client in
 
-    let email_id = Jmap_proto.Id.of_string_exn email_id_str in
+    let email_id = Jmap.Proto.Id.of_string_exn email_id_str in
 
     (* First get the email to find its thread ID - include required properties *)
     let get_inv = Jmap_eio.Client.Build.email_get
···
     in
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
         [get_inv]
     ) in
 
···
                 exit 1
             | email :: _ ->
                 let thread_id = email.thread_id in
-                Jmap_eio.Cli.debug cfg "Thread ID: %s" (Jmap_proto.Id.to_string thread_id);
+                Jmap_eio.Cli.debug cfg "Thread ID: %s" (Jmap.Proto.Id.to_string thread_id);
 
                 (* Get the thread *)
                 let thread_inv = Jmap_eio.Client.Build.thread_get
···
                 in
                 let req2 = Jmap_eio.Client.Build.(
                   make_request
-                    ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+                    ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
                     [thread_inv]
                 ) in
 
···
                             let email_ids = thread.email_ids in
                             Fmt.pr "@[<v>%a %s (%d emails)@,@,"
                               Fmt.(styled `Bold string) "Thread"
-                              (Jmap_proto.Id.to_string thread.id)
+                              (Jmap.Proto.Id.to_string thread.id)
                               (List.length email_ids);
 
                             (* Fetch all emails in thread *)
···
                             in
                             let req3 = Jmap_eio.Client.Build.(
                               make_request
-                                ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail]
+                                ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail]
                                 [get_inv2]
                             ) in
 
···
                                     Fmt.epr "Parse error: %s@." (Jsont.Error.to_string e);
                                     exit 1
                                 | Ok emails_result ->
-                                    List.iter (fun (email : Jmap_mail.Email.t) ->
+                                    List.iter (fun (email : Jmap.Proto.Email.t) ->
                                       let from_str = match email.from with
                                         | Some addrs -> format_email_addresses addrs
                                         | None -> "(unknown)"
                                       in
                                       let subject = Option.value email.subject ~default:"(no subject)" in
                                       Fmt.pr "  %a %s@,"
-                                        Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string email.id)
+                                        Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string email.id)
                                         (ptime_to_string email.received_at);
                                       Fmt.pr "    From: %s@," (truncate_string 60 from_str);
                                       Fmt.pr "    Subject: %a@,@,"
···
 
     let req = Jmap_eio.Client.Build.(
       make_request
-        ~capabilities:[Jmap_proto.Capability.core; Jmap_proto.Capability.mail;
-                       Jmap_proto.Capability.submission]
+        ~capabilities:[Jmap.Proto.Capability.core; Jmap.Proto.Capability.mail;
+                       Jmap.Proto.Capability.submission]
         [identity_get ~call_id:"i1" ~account_id ()]
     ) in
 
···
         exit 1
     | Ok response ->
         match Jmap_eio.Client.Parse.parse_response ~call_id:"i1"
-                (Jmap_eio.Client.Parse.get_response Jmap_mail.Identity.jsont)
+                (Jmap_eio.Client.Parse.get_response Jmap.Proto.Identity.jsont)
                 response with
         | Error e ->
             Fmt.epr "Parse error: %s@." (Jsont.Error.to_string e);
···
             Fmt.pr "@[<v>%a (state: %s)@,@,"
               Fmt.(styled `Bold string) "Identities"
               result.state;
-            List.iter (fun (ident : Jmap_mail.Identity.t) ->
+            List.iter (fun (ident : Jmap.Proto.Identity.t) ->
               Fmt.pr "  %a@,"
-                Fmt.(styled `Cyan string) (Jmap_proto.Id.to_string ident.id);
+                Fmt.(styled `Cyan string) (Jmap.Proto.Id.to_string ident.id);
               Fmt.pr "    Name: %s@," ident.name;
               Fmt.pr "    Email: %a@,"
                 Fmt.(styled `Green string) ident.email;

bin/tutorial_examples.ml

···
 
 open Lwt.Syntax
 open Jmap
-open Jmap_mail
+open Jmap.Mail
 
 (* Example: Authentication *)
 let auth_example () =
···
       Printf.eprintf "Error: JMAP_API_TOKEN environment variable not set\n";
       Lwt.return_none
   | Some token ->
-      let+ result = Jmap_mail.login_with_token 
+      let+ result = Jmap.Proto.login_with_token 
         ~uri:"https://api.fastmail.com/jmap/session" 
         ~api_token:token
       in
···
       | Ok conn -> 
           (* Get the primary account ID *)
           let account_id = 
-            let mail_capability = Jmap_mail.Capability.to_string Jmap_mail.Capability.Mail in
+            let mail_capability = Jmap.Proto.Capability.to_string Jmap.Proto.Capability.Mail in
             match List.assoc_opt mail_capability conn.session.primary_accounts with
             | Some id -> id
             | None -> 
···
 (* Example: Working with Mailboxes *)
 let mailbox_example (conn, account_id) =
   (* Get all mailboxes *)
-  let+ mailboxes_result = Jmap_mail.get_mailboxes conn ~account_id in
+  let+ mailboxes_result = Jmap.Proto.get_mailboxes conn ~account_id in
   
   match mailboxes_result with
   | Ok mailboxes -> 
···
 (* Example: Working with Emails *)
 let email_example (conn, account_id, mailbox_id) =
   (* Get emails from mailbox *)
-  let+ emails_result = Jmap_mail.get_messages_in_mailbox
+  let+ emails_result = Jmap.Proto.get_messages_in_mailbox
     conn
     ~account_id
     ~mailbox_id
···
       Printf.printf "Found %d emails\n" (List.length emails);
       
       (* Display emails *)
-      List.iter (fun (email:Jmap_mail.Types.email) ->
+      List.iter (fun (email:Jmap.Proto.Types.email) ->
         (* Using explicit module path for Types to avoid ambiguity *)
-        let module Mail = Jmap_mail.Types in
+        let module Mail = Jmap.Proto.Types in
         
         (* Get sender info *)
         let from = match email.Mail.from with
···
       
       match emails with
       | [] -> None
-      | hd::_ -> Some (conn, account_id, hd.Jmap_mail.Types.id)
+      | hd::_ -> Some (conn, account_id, hd.Jmap.Proto.Types.id)
   end
   | Error e ->
       Printf.eprintf "Error getting emails: %s\n" 

eio/cli.ml

···
 
 let get_account_id cfg client =
   match cfg.account_id with
-  | Some id -> Jmap_proto.Id.of_string_exn id
+  | Some id -> Jmap.Proto.Id.of_string_exn id
   | None ->
       let session = Client.session client in
-      match Jmap_proto.Session.primary_account_for Jmap_proto.Capability.mail session with
+      match Jmap.Proto.Session.primary_account_for Jmap.Proto.Capability.mail session with
       | Some id -> id
       | None ->
           Fmt.epr "@[<v>%a No primary mail account found. Specify --account.@]@."

eio/cli.mli

···
 (** [create_client ~sw env cfg] creates a JMAP client from the configuration.
     Exits with error message on connection failure. *)
 
-val get_account_id : config -> Client.t -> Jmap_proto.Id.t
+val get_account_id : config -> Client.t -> Jmap.Proto.Id.t
 (** [get_account_id cfg client] returns the account ID from config, or the
     primary mail account if not specified. Exits with error if no account found. *)
 

eio/client.ml

···
 
 type error =
   | Http_error of int * string
-  | Jmap_error of Jmap_proto.Error.Request_error.t
+  | Jmap_error of Jmap.Proto.Error.Request_error.t
   | Json_error of Jsont.Error.t
   | Session_error of string
   | Connection_error of string
···
       Format.fprintf fmt "HTTP error %d: %s" code msg
   | Jmap_error err ->
       Format.fprintf fmt "JMAP error: %s"
-        (Jmap_proto.Error.Request_error.urn_to_string err.type_)
+        (Jmap.Proto.Error.Request_error.urn_to_string err.type_)
   | Json_error err ->
       Format.fprintf fmt "JSON error: %s" (Jsont.Error.to_string err)
   | Session_error msg ->
···
 exception Jmap_client_error of error
 
 type t = {
-  mutable session : Jmap_proto.Session.t;
+  mutable session : Jmap.Proto.Session.t;
   requests : Requests.t;
   auth : Requests.Auth.t option;
   session_url : string;
 }
 
 let session t = t.session
-let api_url t = Jmap_proto.Session.api_url t.session
-let upload_url t = Jmap_proto.Session.upload_url t.session
-let download_url t = Jmap_proto.Session.download_url t.session
+let api_url t = Jmap.Proto.Session.api_url t.session
+let upload_url t = Jmap.Proto.Session.upload_url t.session
+let download_url t = Jmap.Proto.Session.download_url t.session
 
 let create ?auth ~session requests =
-  let session_url = Jmap_proto.Session.api_url session in
+  let session_url = Jmap.Proto.Session.api_url session in
   { session; requests; auth; session_url }
 
 let fetch_session ?auth requests url =
···
 
 let expand_upload_url t ~account_id =
   let template = upload_url t in
-  let account_id_str = Jmap_proto.Id.to_string account_id in
+  let account_id_str = Jmap.Proto.Id.to_string account_id in
   (* Simple template expansion for {accountId} *)
   let re = Str.regexp "{accountId}" in
   Str.global_replace re account_id_str template
···
 
 let expand_download_url t ~account_id ~blob_id ?name ?accept () =
   let template = download_url t in
-  let account_id_str = Jmap_proto.Id.to_string account_id in
-  let blob_id_str = Jmap_proto.Id.to_string blob_id in
+  let account_id_str = Jmap.Proto.Id.to_string account_id in
+  let blob_id_str = Jmap.Proto.Id.to_string blob_id in
   let name_str = Option.value name ~default:"download" in
   let type_str = Option.value accept ~default:"application/octet-stream" in
   (* Simple template expansion *)
···
 
 (* Convenience builders *)
 module Build = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let json_of_id id =
     Jsont.String (Id.to_string id, Jsont.Meta.none)
···
     let args = match filter with
       | None -> args
       | Some f ->
-          ("filter", encode_to_json Jmap_mail.Mail_filter.mailbox_filter_jsont f) :: args
+          ("filter", encode_to_json Jmap.Proto.Mail_filter.mailbox_filter_jsont f) :: args
     in
     let args = match sort with
       | None -> args
···
     let args = match filter with
       | None -> args
       | Some f ->
-          ("filter", encode_to_json Jmap_mail.Mail_filter.email_filter_jsont f) :: args
+          ("filter", encode_to_json Jmap.Proto.Mail_filter.email_filter_jsont f) :: args
     in
     let args = match sort with
       | None -> args
···
     let args = match filter with
       | None -> args
       | Some f ->
-          ("filter", encode_to_json Jmap_mail.Mail_filter.submission_filter_jsont f) :: args
+          ("filter", encode_to_json Jmap.Proto.Mail_filter.submission_filter_jsont f) :: args
     in
     let args = match sort with
       | None -> args
···
   let vacation_response_get ~call_id ~account_id () =
     let args = [
       ("accountId", json_of_id account_id);
-      ("ids", json_of_id_list [Jmap_mail.Vacation.singleton_id]);
+      ("ids", json_of_id_list [Jmap.Proto.Vacation.singleton_id]);
     ] in
     make_invocation ~name:"VacationResponse/get" ~call_id args
 
···
 
 (* Response parsing helpers *)
 module Parse = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let decode_from_json jsont json =
     Jsont.Json.decode' jsont json
···
   (* Mail-specific parsers *)
 
   let mailbox_get_response =
-    get_response Jmap_mail.Mailbox.jsont
+    get_response Jmap.Proto.Mailbox.jsont
 
   let email_get_response =
-    get_response Jmap_mail.Email.jsont
+    get_response Jmap.Proto.Email.jsont
 
   let thread_get_response =
-    get_response Jmap_mail.Thread.jsont
+    get_response Jmap.Proto.Thread.jsont
 
   let identity_get_response =
-    get_response Jmap_mail.Identity.jsont
+    get_response Jmap.Proto.Identity.jsont
 
   (* Convenience functions *)
 

eio/client.mli

···
 type error =
   | Http_error of int * string
       (** HTTP error with status code and message. *)
-  | Jmap_error of Jmap_proto.Error.Request_error.t
+  | Jmap_error of Jmap.Proto.Error.Request_error.t
       (** JMAP protocol error at request level. *)
   | Json_error of Jsont.Error.t
       (** JSON encoding/decoding error. *)
···
 
 val create :
   ?auth:Requests.Auth.t ->
-  session:Jmap_proto.Session.t ->
+  session:Jmap.Proto.Session.t ->
   Requests.t ->
   t
 (** [create ?auth ~session requests] creates a JMAP client from an existing
···
 
 (** {1 Session Access} *)
 
-val session : t -> Jmap_proto.Session.t
+val session : t -> Jmap.Proto.Session.t
 (** [session client] returns the current JMAP session. *)
 
 val refresh_session : t -> (unit, error) result
···
 
 val request :
   t ->
-  Jmap_proto.Request.t ->
-  (Jmap_proto.Response.t, error) result
+  Jmap.Proto.Request.t ->
+  (Jmap.Proto.Response.t, error) result
 (** [request client req] executes a JMAP request and returns the response. *)
 
 val request_exn :
   t ->
-  Jmap_proto.Request.t ->
-  Jmap_proto.Response.t
+  Jmap.Proto.Request.t ->
+  Jmap.Proto.Response.t
 (** [request_exn client req] is like {!request} but raises on error. *)
 
 (** {1 Blob Operations} *)
 
 val upload :
   t ->
-  account_id:Jmap_proto.Id.t ->
+  account_id:Jmap.Proto.Id.t ->
   content_type:string ->
   data:string ->
-  (Jmap_proto.Blob.upload_response, error) result
+  (Jmap.Proto.Blob.upload_response, error) result
 (** [upload client ~account_id ~content_type ~data] uploads a blob.
 
     @param account_id The account to upload to.
···
 
 val upload_exn :
   t ->
-  account_id:Jmap_proto.Id.t ->
+  account_id:Jmap.Proto.Id.t ->
   content_type:string ->
   data:string ->
-  Jmap_proto.Blob.upload_response
+  Jmap.Proto.Blob.upload_response
 (** [upload_exn client ~account_id ~content_type ~data] is like {!upload}
     but raises on error. *)
 
 val download :
   t ->
-  account_id:Jmap_proto.Id.t ->
-  blob_id:Jmap_proto.Id.t ->
+  account_id:Jmap.Proto.Id.t ->
+  blob_id:Jmap.Proto.Id.t ->
   ?name:string ->
   ?accept:string ->
   unit ->
···
 
 val download_exn :
   t ->
-  account_id:Jmap_proto.Id.t ->
-  blob_id:Jmap_proto.Id.t ->
+  account_id:Jmap.Proto.Id.t ->
+  blob_id:Jmap.Proto.Id.t ->
   ?name:string ->
   ?accept:string ->
   unit ->
···
   val echo :
     call_id:string ->
     Jsont.json ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [echo ~call_id data] builds a Core/echo invocation. *)
 
   (** {2 Mailbox Methods} *)
 
   val mailbox_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?ids:Jmap_proto.Id.t list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?ids:Jmap.Proto.Id.t list ->
     ?properties:string list ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [mailbox_get ~call_id ~account_id ?ids ?properties ()] builds a
       Mailbox/get invocation. *)
 
   val mailbox_changes :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
+    account_id:Jmap.Proto.Id.t ->
     since_state:string ->
     ?max_changes:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [mailbox_changes ~call_id ~account_id ~since_state ?max_changes ()]
       builds a Mailbox/changes invocation. *)
 
   val mailbox_query :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?filter:Jmap_mail.Mail_filter.mailbox_filter ->
-    ?sort:Jmap_proto.Filter.comparator list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?filter:Jmap.Proto.Mail_filter.mailbox_filter ->
+    ?sort:Jmap.Proto.Filter.comparator list ->
     ?position:int64 ->
     ?limit:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [mailbox_query ~call_id ~account_id ?filter ?sort ?position ?limit ()]
       builds a Mailbox/query invocation. *)
 
···
 
   val email_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?ids:Jmap_proto.Id.t list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?ids:Jmap.Proto.Id.t list ->
     ?properties:string list ->
     ?body_properties:string list ->
     ?fetch_text_body_values:bool ->
···
     ?fetch_all_body_values:bool ->
     ?max_body_value_bytes:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [email_get ~call_id ~account_id ?ids ?properties ...] builds an
       Email/get invocation. *)
 
   val email_changes :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
+    account_id:Jmap.Proto.Id.t ->
     since_state:string ->
     ?max_changes:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [email_changes ~call_id ~account_id ~since_state ?max_changes ()]
       builds an Email/changes invocation. *)
 
   val email_query :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?filter:Jmap_mail.Mail_filter.email_filter ->
-    ?sort:Jmap_proto.Filter.comparator list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?filter:Jmap.Proto.Mail_filter.email_filter ->
+    ?sort:Jmap.Proto.Filter.comparator list ->
     ?position:int64 ->
     ?limit:int64 ->
     ?collapse_threads:bool ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [email_query ~call_id ~account_id ?filter ?sort ?position ?limit
       ?collapse_threads ()] builds an Email/query invocation. *)
 
···
 
   val thread_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?ids:Jmap_proto.Id.t list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?ids:Jmap.Proto.Id.t list ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [thread_get ~call_id ~account_id ?ids ()] builds a Thread/get invocation. *)
 
   val thread_changes :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
+    account_id:Jmap.Proto.Id.t ->
     since_state:string ->
     ?max_changes:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [thread_changes ~call_id ~account_id ~since_state ?max_changes ()]
       builds a Thread/changes invocation. *)
 
···
 
   val identity_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?ids:Jmap_proto.Id.t list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?ids:Jmap.Proto.Id.t list ->
     ?properties:string list ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [identity_get ~call_id ~account_id ?ids ?properties ()] builds an
       Identity/get invocation. *)
 
···
 
   val email_submission_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?ids:Jmap_proto.Id.t list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?ids:Jmap.Proto.Id.t list ->
     ?properties:string list ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [email_submission_get ~call_id ~account_id ?ids ?properties ()]
       builds an EmailSubmission/get invocation. *)
 
   val email_submission_query :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
-    ?filter:Jmap_mail.Mail_filter.submission_filter ->
-    ?sort:Jmap_proto.Filter.comparator list ->
+    account_id:Jmap.Proto.Id.t ->
+    ?filter:Jmap.Proto.Mail_filter.submission_filter ->
+    ?sort:Jmap.Proto.Filter.comparator list ->
     ?position:int64 ->
     ?limit:int64 ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [email_submission_query ~call_id ~account_id ?filter ?sort ?position
       ?limit ()] builds an EmailSubmission/query invocation. *)
 
···
 
   val vacation_response_get :
     call_id:string ->
-    account_id:Jmap_proto.Id.t ->
+    account_id:Jmap.Proto.Id.t ->
     unit ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Invocation.t
   (** [vacation_response_get ~call_id ~account_id ()] builds a
       VacationResponse/get invocation. The singleton ID is automatically used. *)
 
   (** {2 Request Building} *)
 
   val make_request :
-    ?created_ids:(Jmap_proto.Id.t * Jmap_proto.Id.t) list ->
+    ?created_ids:(Jmap.Proto.Id.t * Jmap.Proto.Id.t) list ->
     capabilities:string list ->
-    Jmap_proto.Invocation.t list ->
-    Jmap_proto.Request.t
+    Jmap.Proto.Invocation.t list ->
+    Jmap.Proto.Request.t
   (** [make_request ?created_ids ~capabilities invocations] builds a JMAP request.
 
       @param created_ids Optional client-created ID mappings.
···
 module Parse : sig
   val find_invocation :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    Jmap_proto.Invocation.t option
+    Jmap.Proto.Response.t ->
+    Jmap.Proto.Invocation.t option
   (** [find_invocation ~call_id response] finds an invocation by call ID. *)
 
   val get_invocation_exn :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    Jmap_proto.Invocation.t
+    Jmap.Proto.Response.t ->
+    Jmap.Proto.Invocation.t
   (** [get_invocation_exn ~call_id response] finds an invocation by call ID.
       @raise Failure if not found. *)
 
   val parse_invocation :
     'a Jsont.t ->
-    Jmap_proto.Invocation.t ->
+    Jmap.Proto.Invocation.t ->
     ('a, Jsont.Error.t) result
   (** [parse_invocation jsont inv] decodes the invocation's arguments. *)
 
   val parse_response :
     call_id:string ->
     'a Jsont.t ->
-    Jmap_proto.Response.t ->
+    Jmap.Proto.Response.t ->
     ('a, Jsont.Error.t) result
   (** [parse_response ~call_id jsont response] finds and parses an invocation. *)
 
   (** {2 Typed Response Codecs} *)
 
-  val get_response : 'a Jsont.t -> 'a Jmap_proto.Method.get_response Jsont.t
+  val get_response : 'a Jsont.t -> 'a Jmap.Proto.Method.get_response Jsont.t
   (** [get_response obj_jsont] creates a Foo/get response codec. *)
 
-  val query_response : Jmap_proto.Method.query_response Jsont.t
+  val query_response : Jmap.Proto.Method.query_response Jsont.t
   (** Codec for Foo/query responses. *)
 
-  val changes_response : Jmap_proto.Method.changes_response Jsont.t
+  val changes_response : Jmap.Proto.Method.changes_response Jsont.t
   (** Codec for Foo/changes responses. *)
 
-  val set_response : 'a Jsont.t -> 'a Jmap_proto.Method.set_response Jsont.t
+  val set_response : 'a Jsont.t -> 'a Jmap.Proto.Method.set_response Jsont.t
   (** [set_response obj_jsont] creates a Foo/set response codec. *)
 
   (** {2 Mail-specific Codecs} *)
 
-  val mailbox_get_response : Jmap_mail.Mailbox.t Jmap_proto.Method.get_response Jsont.t
-  val email_get_response : Jmap_mail.Email.t Jmap_proto.Method.get_response Jsont.t
-  val thread_get_response : Jmap_mail.Thread.t Jmap_proto.Method.get_response Jsont.t
-  val identity_get_response : Jmap_mail.Identity.t Jmap_proto.Method.get_response Jsont.t
+  val mailbox_get_response : Jmap.Proto.Mailbox.t Jmap.Proto.Method.get_response Jsont.t
+  val email_get_response : Jmap.Proto.Email.t Jmap.Proto.Method.get_response Jsont.t
+  val thread_get_response : Jmap.Proto.Thread.t Jmap.Proto.Method.get_response Jsont.t
+  val identity_get_response : Jmap.Proto.Identity.t Jmap.Proto.Method.get_response Jsont.t
 
   (** {2 Convenience Parsers} *)
 
   val parse_mailbox_get :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    (Jmap_mail.Mailbox.t Jmap_proto.Method.get_response, Jsont.Error.t) result
+    Jmap.Proto.Response.t ->
+    (Jmap.Proto.Mailbox.t Jmap.Proto.Method.get_response, Jsont.Error.t) result
 
   val parse_email_get :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    (Jmap_mail.Email.t Jmap_proto.Method.get_response, Jsont.Error.t) result
+    Jmap.Proto.Response.t ->
+    (Jmap.Proto.Email.t Jmap.Proto.Method.get_response, Jsont.Error.t) result
 
   val parse_email_query :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    (Jmap_proto.Method.query_response, Jsont.Error.t) result
+    Jmap.Proto.Response.t ->
+    (Jmap.Proto.Method.query_response, Jsont.Error.t) result
 
   val parse_thread_get :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    (Jmap_mail.Thread.t Jmap_proto.Method.get_response, Jsont.Error.t) result
+    Jmap.Proto.Response.t ->
+    (Jmap.Proto.Thread.t Jmap.Proto.Method.get_response, Jsont.Error.t) result
 
   val parse_changes :
     call_id:string ->
-    Jmap_proto.Response.t ->
-    (Jmap_proto.Method.changes_response, Jsont.Error.t) result
+    Jmap.Proto.Response.t ->
+    (Jmap.Proto.Method.changes_response, Jsont.Error.t) result
 end

eio/codec.ml

···
   Jsont_bytesrw.decode_string' ?locs jsont json
 
 let encode_request ?format request =
-  encode ?format Jmap_proto.Request.jsont request
+  encode ?format Jmap.Proto.Request.jsont request
 
 let encode_request_exn ?format request =
   match encode_request ?format request with
···
   | Error e -> failwith (Jsont.Error.to_string e)
 
 let decode_response ?locs json =
-  decode ?locs Jmap_proto.Response.jsont json
+  decode ?locs Jmap.Proto.Response.jsont json
 
 let decode_response_exn ?locs json =
   match decode_response ?locs json with
···
   | Error e -> failwith (Jsont.Error.to_string e)
 
 let decode_session ?locs json =
-  decode ?locs Jmap_proto.Session.jsont json
+  decode ?locs Jmap.Proto.Session.jsont json
 
 let decode_session_exn ?locs json =
   match decode_session ?locs json with
···
   | Error e -> failwith (Jsont.Error.to_string e)
 
 let decode_upload_response ?locs json =
-  decode ?locs Jmap_proto.Blob.upload_response_jsont json
+  decode ?locs Jmap.Proto.Blob.upload_response_jsont json
 
 let decode_upload_response_exn ?locs json =
   match decode_upload_response ?locs json with

eio/codec.mli

···
 
 val encode_request :
   ?format:Jsont.format ->
-  Jmap_proto.Request.t ->
+  Jmap.Proto.Request.t ->
   (string, Jsont.Error.t) result
 (** [encode_request ?format request] encodes a JMAP request to a JSON string.
 
···
 
 val encode_request_exn :
   ?format:Jsont.format ->
-  Jmap_proto.Request.t ->
+  Jmap.Proto.Request.t ->
   string
 (** [encode_request_exn ?format request] is like {!encode_request} but raises
     on encoding errors. *)
···
 val decode_response :
   ?locs:bool ->
   string ->
-  (Jmap_proto.Response.t, Jsont.Error.t) result
+  (Jmap.Proto.Response.t, Jsont.Error.t) result
 (** [decode_response ?locs json] decodes a JMAP response from a JSON string.
 
     @param locs If [true], location information is preserved for error messages.
···
 val decode_response_exn :
   ?locs:bool ->
   string ->
-  Jmap_proto.Response.t
+  Jmap.Proto.Response.t
 (** [decode_response_exn ?locs json] is like {!decode_response} but raises
     on decoding errors. *)
 
···
 val decode_session :
   ?locs:bool ->
   string ->
-  (Jmap_proto.Session.t, Jsont.Error.t) result
+  (Jmap.Proto.Session.t, Jsont.Error.t) result
 (** [decode_session ?locs json] decodes a JMAP session from a JSON string.
 
     @param locs If [true], location information is preserved for error messages.
···
 val decode_session_exn :
   ?locs:bool ->
   string ->
-  Jmap_proto.Session.t
+  Jmap.Proto.Session.t
 (** [decode_session_exn ?locs json] is like {!decode_session} but raises
     on decoding errors. *)
 
···
 val decode_upload_response :
   ?locs:bool ->
   string ->
-  (Jmap_proto.Blob.upload_response, Jsont.Error.t) result
+  (Jmap.Proto.Blob.upload_response, Jsont.Error.t) result
 (** [decode_upload_response ?locs json] decodes a blob upload response. *)
 
 val decode_upload_response_exn :
   ?locs:bool ->
   string ->
-  Jmap_proto.Blob.upload_response
+  Jmap.Proto.Blob.upload_response
 (** [decode_upload_response_exn ?locs json] is like {!decode_upload_response}
     but raises on decoding errors. *)
 

eio/dune

···
 (library
  (name jmap_eio)
  (public_name jmap-eio)
- (libraries jmap jmap.mail jsont jsont.bytesrw eio requests uri str cmdliner fmt.tty)
+ (libraries jmap jsont jsont.bytesrw eio requests uri str cmdliner fmt.tty)
  (modules jmap_eio codec client cli))

eio/jmap_eio.mli

···
 
         (* Get session info *)
         let session = Jmap_eio.Client.session client in
-        Printf.printf "API URL: %s\n" (Jmap_proto.Session.api_url session);
+        Printf.printf "API URL: %s\n" (Jmap.Proto.Session.api_url session);
 
         (* Build and execute a request *)
         let account_id = (* get from session *) ... in
         let req = Jmap_eio.Client.Build.(
           make_request
-            ~capabilities:[Jmap_proto.Capability.core_uri;
-                          Jmap_proto.Capability.mail_uri]
+            ~capabilities:[Jmap.Proto.Capability.core_uri;
+                          Jmap.Proto.Capability.mail_uri]
             [mailbox_get ~call_id:"0" ~account_id ()]
         ) in
         let response = Jmap_eio.Client.request_exn client req in
···
         (* Process response *)
         List.iter (fun inv ->
           Printf.printf "Method: %s, CallId: %s\n"
-            (Jmap_proto.Invocation.name inv)
-            (Jmap_proto.Invocation.method_call_id inv)
-        ) (Jmap_proto.Response.method_responses response)
+            (Jmap.Proto.Invocation.name inv)
+            (Jmap.Proto.Invocation.method_call_id inv)
+        ) (Jmap.Proto.Response.method_responses response)
     ]}
 
     {2 Capabilities}
···
     - [urn:ietf:params:jmap:submission] - EmailSubmission
     - [urn:ietf:params:jmap:vacationresponse] - VacationResponse
 
-    These are available as constants in {!Jmap_proto.Capability}.
+    These are available as constants in {!Jmap.Proto.Capability}.
 *)
 
 (** Low-level JSON codec for JMAP messages. *)

lib/core/jmap.ml

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+(** Unified JMAP interface for OCaml
+
+    This module provides a clean, ergonomic API for working with JMAP
+    (RFC 8620/8621), combining the protocol and mail layers with abstract
+    types and polymorphic variants.
+
+    {2 Quick Start}
+
+    {[
+      open Jmap
+
+      (* Keywords use polymorphic variants *)
+      let is_unread email =
+        not (List.mem `Seen (Email.keywords email))
+
+      (* Mailbox roles are also polymorphic *)
+      let find_inbox mailboxes =
+        List.find_opt (fun m -> Mailbox.role m = Some `Inbox) mailboxes
+    ]}
+
+    {2 Module Structure}
+
+    - {!Proto} - Low-level protocol and mail types (RFC 8620/8621)
+    - {!Error}, {!Id}, {!Keyword}, {!Role}, {!Capability} - Core types
+    - {!Session}, {!Email}, {!Mailbox}, etc. - Abstract type accessors
+*)
+
+(** {1 Protocol Layer Re-exports} *)
+
+(** Low-level JMAP protocol types (RFC 8620/8621).
+
+    These are the raw protocol and mail types. For most use cases, prefer the
+    higher-level types in this module. *)
+module Proto = Jmap_proto
+
+(** {1 Core Types} *)
+
+(** Unified error type for JMAP operations.
+
+    All errors from JSON parsing, HTTP, session management, and JMAP method
+    calls are represented as polymorphic variants. *)
+module Error = Jmap_types.Error
+
+(** JMAP identifier type.
+
+    Identifiers are opaque strings assigned by the server. *)
+module Id = Jmap_types.Id
+
+(** Email keyword type.
+
+    Standard keywords are represented as polymorphic variants.
+    Custom keywords use [`Custom of string]. *)
+module Keyword = Jmap_types.Keyword
+
+(** Mailbox role type.
+
+    Standard roles are represented as polymorphic variants.
+    Custom roles use [`Custom of string]. *)
+module Role = Jmap_types.Role
+
+(** JMAP capability type.
+
+    Standard capabilities are represented as polymorphic variants.
+    Custom capabilities use [`Custom of string]. *)
+module Capability = Jmap_types.Capability
+
+(** {1 Session Types} *)
+
+(** JMAP session information.
+
+    The session contains server capabilities, account information,
+    and API endpoint URLs. *)
+module Session = struct
+  (** Account information. *)
+  module Account = struct
+    type t = Jmap_types.account
+
+    let name a = Proto.Session.Account.name a
+    let is_personal a = Proto.Session.Account.is_personal a
+    let is_read_only a = Proto.Session.Account.is_read_only a
+  end
+
+  type t = Jmap_types.session
+
+  let capabilities s = Proto.Session.capabilities s
+  let accounts s = Proto.Session.accounts s
+  let primary_accounts s = Proto.Session.primary_accounts s
+  let username s = Proto.Session.username s
+  let api_url s = Proto.Session.api_url s
+  let download_url s = Proto.Session.download_url s
+  let upload_url s = Proto.Session.upload_url s
+  let event_source_url s = Proto.Session.event_source_url s
+  let state s = Proto.Session.state s
+
+  let get_account id s = Proto.Session.get_account id s
+  let primary_account_for cap s = Proto.Session.primary_account_for cap s
+  let has_capability uri s = Proto.Session.has_capability uri s
+end
+
+(** {1 Mail Types} *)
+
+(** Email address with optional display name. *)
+module Email_address = struct
+  type t = Jmap_types.email_address
+
+  let name a = Proto.Email_address.name a
+  let email a = Proto.Email_address.email a
+
+  let create ?name email =
+    Proto.Email_address.create ?name email
+end
+
+(** Email mailbox. *)
+module Mailbox = struct
+  type t = Jmap_types.mailbox
+
+  let id m = Proto.Mailbox.id m
+  let name m = Proto.Mailbox.name m
+  let parent_id m = Proto.Mailbox.parent_id m
+  let sort_order m = Proto.Mailbox.sort_order m
+  let total_emails m = Proto.Mailbox.total_emails m
+  let unread_emails m = Proto.Mailbox.unread_emails m
+  let total_threads m = Proto.Mailbox.total_threads m
+  let unread_threads m = Proto.Mailbox.unread_threads m
+  let is_subscribed m = Proto.Mailbox.is_subscribed m
+
+  let role m =
+    let convert_role = function
+      | Proto.Mailbox.Inbox -> `Inbox
+      | Proto.Mailbox.Sent -> `Sent
+      | Proto.Mailbox.Drafts -> `Drafts
+      | Proto.Mailbox.Trash -> `Trash
+      | Proto.Mailbox.Junk -> `Junk
+      | Proto.Mailbox.Archive -> `Archive
+      | Proto.Mailbox.Flagged -> `Flagged
+      | Proto.Mailbox.Important -> `Important
+      | Proto.Mailbox.All -> `All
+      | Proto.Mailbox.Subscribed -> `Subscribed
+      | Proto.Mailbox.Other s -> `Custom s
+    in
+    Option.map convert_role (Proto.Mailbox.role m)
+
+  (** Mailbox rights. *)
+  module Rights = struct
+    type t = Proto.Mailbox.Rights.t
+
+    let may_read_items r = Proto.Mailbox.Rights.may_read_items r
+    let may_add_items r = Proto.Mailbox.Rights.may_add_items r
+    let may_remove_items r = Proto.Mailbox.Rights.may_remove_items r
+    let may_set_seen r = Proto.Mailbox.Rights.may_set_seen r
+    let may_set_keywords r = Proto.Mailbox.Rights.may_set_keywords r
+    let may_create_child r = Proto.Mailbox.Rights.may_create_child r
+    let may_rename r = Proto.Mailbox.Rights.may_rename r
+    let may_delete r = Proto.Mailbox.Rights.may_delete r
+    let may_submit r = Proto.Mailbox.Rights.may_submit r
+  end
+
+  let my_rights m = Proto.Mailbox.my_rights m
+end
+
+(** Email thread. *)
+module Thread = struct
+  type t = Jmap_types.thread
+
+  let id t = Proto.Thread.id t
+  let email_ids t = Proto.Thread.email_ids t
+end
+
+(** Email message. *)
+module Email = struct
+  (** Email body part. *)
+  module Body = struct
+    type part = Proto.Email_body.Part.t
+    type value = Proto.Email_body.Value.t
+
+    let part_id p = Proto.Email_body.Part.part_id p
+    let blob_id p = Proto.Email_body.Part.blob_id p
+    let size p = Proto.Email_body.Part.size p
+    let name p = Proto.Email_body.Part.name p
+    let type_ p = Proto.Email_body.Part.type_ p
+    let charset p = Proto.Email_body.Part.charset p
+    let disposition p = Proto.Email_body.Part.disposition p
+    let cid p = Proto.Email_body.Part.cid p
+    let language p = Proto.Email_body.Part.language p
+    let location p = Proto.Email_body.Part.location p
+
+    let value_text v = Proto.Email_body.Value.value v
+    let value_is_truncated v = Proto.Email_body.Value.is_truncated v
+    let value_is_encoding_problem v = Proto.Email_body.Value.is_encoding_problem v
+  end
+
+  type t = Jmap_types.email
+
+  let id e = Proto.Email.id e
+  let blob_id e = Proto.Email.blob_id e
+  let thread_id e = Proto.Email.thread_id e
+  let mailbox_ids e = Proto.Email.mailbox_ids e
+  let size e = Proto.Email.size e
+  let received_at e = Proto.Email.received_at e
+  let message_id e = Proto.Email.message_id e
+  let in_reply_to e = Proto.Email.in_reply_to e
+  let references e = Proto.Email.references e
+  let subject e = Proto.Email.subject e
+  let sent_at e = Proto.Email.sent_at e
+  let has_attachment e = Proto.Email.has_attachment e
+  let preview e = Proto.Email.preview e
+
+  (** Get active keywords as polymorphic variants. *)
+  let keywords e =
+    let kw_map = Proto.Email.keywords e in
+    List.filter_map (fun (k, v) ->
+      if v then Some (Keyword.of_string k) else None
+    ) kw_map
+
+  (** Check if email has a specific keyword. *)
+  let has_keyword kw e =
+    let kw_str = Keyword.to_string kw in
+    let kw_map = Proto.Email.keywords e in
+    List.exists (fun (k, v) -> k = kw_str && v) kw_map
+
+  let from e = Proto.Email.from e
+  let to_ e = Proto.Email.to_ e
+  let cc e = Proto.Email.cc e
+  let bcc e = Proto.Email.bcc e
+  let reply_to e = Proto.Email.reply_to e
+  let sender e = Proto.Email.sender e
+
+  let text_body e = Proto.Email.text_body e
+  let html_body e = Proto.Email.html_body e
+  let attachments e = Proto.Email.attachments e
+  let body_values e = Proto.Email.body_values e
+end
+
+(** Email identity for sending. *)
+module Identity = struct
+  type t = Jmap_types.identity
+
+  let id i = Proto.Identity.id i
+  let name i = Proto.Identity.name i
+  let email i = Proto.Identity.email i
+  let reply_to i = Proto.Identity.reply_to i
+  let bcc i = Proto.Identity.bcc i
+  let text_signature i = Proto.Identity.text_signature i
+  let html_signature i = Proto.Identity.html_signature i
+  let may_delete i = Proto.Identity.may_delete i
+end
+
+(** Email submission for outgoing mail. *)
+module Submission = struct
+  type t = Jmap_types.submission
+
+  let id s = Proto.Submission.id s
+  let identity_id s = Proto.Submission.identity_id s
+  let email_id s = Proto.Submission.email_id s
+  let thread_id s = Proto.Submission.thread_id s
+  let send_at s = Proto.Submission.send_at s
+  let undo_status s = Proto.Submission.undo_status s
+  let delivery_status s = Proto.Submission.delivery_status s
+  let dsn_blob_ids s = Proto.Submission.dsn_blob_ids s
+  let mdn_blob_ids s = Proto.Submission.mdn_blob_ids s
+end
+
+(** Vacation auto-response. *)
+module Vacation = struct
+  type t = Jmap_types.vacation
+
+  let id v = Proto.Vacation.id v
+  let is_enabled v = Proto.Vacation.is_enabled v
+  let from_date v = Proto.Vacation.from_date v
+  let to_date v = Proto.Vacation.to_date v
+  let subject v = Proto.Vacation.subject v
+  let text_body v = Proto.Vacation.text_body v
+  let html_body v = Proto.Vacation.html_body v
+end
+
+(** Search snippet with highlighted matches. *)
+module Search_snippet = struct
+  type t = Jmap_types.search_snippet
+
+  let email_id s = Proto.Search_snippet.email_id s
+  let subject s = Proto.Search_snippet.subject s
+  let preview s = Proto.Search_snippet.preview s
+end
+
+(** {1 Filter Types} *)
+
+(** Email filter conditions for queries. *)
+module Email_filter = struct
+  type condition = Proto.Email.Filter_condition.t
+
+  (** Create an email filter condition.
+
+      All parameters are optional. Omitted parameters are not included
+      in the filter. Use [make ()] for an empty filter. *)
+  let make
+      ?in_mailbox
+      ?in_mailbox_other_than
+      ?before
+      ?after
+      ?min_size
+      ?max_size
+      ?(all_in_thread_have_keyword : Keyword.t option)
+      ?(some_in_thread_have_keyword : Keyword.t option)
+      ?(none_in_thread_have_keyword : Keyword.t option)
+      ?(has_keyword : Keyword.t option)
+      ?(not_keyword : Keyword.t option)
+      ?has_attachment
+      ?text
+      ?from
+      ?to_
+      ?cc
+      ?bcc
+      ?subject
+      ?body
+      ?header
+      () : condition =
+    {
+      in_mailbox;
+      in_mailbox_other_than;
+      before;
+      after;
+      min_size;
+      max_size;
+      all_in_thread_have_keyword = Option.map Keyword.to_string all_in_thread_have_keyword;
+      some_in_thread_have_keyword = Option.map Keyword.to_string some_in_thread_have_keyword;
+      none_in_thread_have_keyword = Option.map Keyword.to_string none_in_thread_have_keyword;
+      has_keyword = Option.map Keyword.to_string has_keyword;
+      not_keyword = Option.map Keyword.to_string not_keyword;
+      has_attachment;
+      text;
+      from;
+      to_;
+      cc;
+      bcc;
+      subject;
+      body;
+      header;
+    }
+end
+
+(** Mailbox filter conditions for queries. *)
+module Mailbox_filter = struct
+  type condition = Proto.Mailbox.Filter_condition.t
+
+  let convert_role = function
+    | `Inbox -> Proto.Mailbox.Inbox
+    | `Sent -> Proto.Mailbox.Sent
+    | `Drafts -> Proto.Mailbox.Drafts
+    | `Trash -> Proto.Mailbox.Trash
+    | `Junk -> Proto.Mailbox.Junk
+    | `Archive -> Proto.Mailbox.Archive
+    | `Flagged -> Proto.Mailbox.Flagged
+    | `Important -> Proto.Mailbox.Important
+    | `All -> Proto.Mailbox.All
+    | `Subscribed -> Proto.Mailbox.Subscribed
+    | `Custom s -> Proto.Mailbox.Other s
+
+  (** Create a mailbox filter condition.
+
+      All parameters are optional.
+      For [role]: [Some (Some r)] filters by role [r], [Some None] filters for
+      mailboxes with no role, [None] doesn't filter by role. *)
+  let make
+      ?parent_id
+      ?name
+      ?role
+      ?has_any_role
+      ?is_subscribed
+      () : condition =
+    {
+      parent_id;
+      name;
+      role = Option.map (Option.map convert_role) role;
+      has_any_role;
+      is_subscribed;
+    }
+end
+
+(** {1 Response Types} *)
+
+(** Generic /get response wrapper. *)
+module Get_response = struct
+  type 'a t = 'a Proto.Method.get_response
+
+  let account_id (r : 'a t) = r.Proto.Method.account_id
+  let state (r : 'a t) = r.Proto.Method.state
+  let list (r : 'a t) = r.Proto.Method.list
+  let not_found (r : 'a t) = r.Proto.Method.not_found
+end
+
+(** Query response. *)
+module Query_response = struct
+  type t = Proto.Method.query_response
+
+  let account_id (r : t) = r.Proto.Method.account_id
+  let query_state (r : t) = r.Proto.Method.query_state
+  let can_calculate_changes (r : t) = r.Proto.Method.can_calculate_changes
+  let position (r : t) = r.Proto.Method.position
+  let ids (r : t) = r.Proto.Method.ids
+  let total (r : t) = r.Proto.Method.total
+end
+
+(** Changes response. *)
+module Changes_response = struct
+  type t = Proto.Method.changes_response
+
+  let account_id (r : t) = r.Proto.Method.account_id
+  let old_state (r : t) = r.Proto.Method.old_state
+  let new_state (r : t) = r.Proto.Method.new_state
+  let has_more_changes (r : t) = r.Proto.Method.has_more_changes
+  let created (r : t) = r.Proto.Method.created
+  let updated (r : t) = r.Proto.Method.updated
+  let destroyed (r : t) = r.Proto.Method.destroyed
+end
+
+(** {1 JSONABLE Interface} *)
+
+(** Module type for types that can be serialized to/from JSON bytes. *)
+module type JSONABLE = sig
+  type t
+
+  val of_string : string -> (t, Error.t) result
+  val to_string : t -> (string, Error.t) result
+end
+
+(** {1 Private Interface} *)
+
+(** Private module for internal use by Jmap_eio.
+
+    This exposes the underlying Jsont codecs for serialization. *)
+module Private = struct
+  module Session = struct
+    let jsont = Proto.Session.jsont
+  end
+
+  module Request = struct
+    let jsont = Proto.Request.jsont
+  end
+
+  module Response = struct
+    let jsont = Proto.Response.jsont
+  end
+
+  module Mailbox = struct
+    let jsont = Proto.Mailbox.jsont
+  end
+
+  module Email = struct
+    let jsont = Proto.Email.jsont
+  end
+
+  module Thread = struct
+    let jsont = Proto.Thread.jsont
+  end
+
+  module Identity = struct
+    let jsont = Proto.Identity.jsont
+  end
+
+  module Submission = struct
+    let jsont = Proto.Submission.jsont
+  end
+
+  module Vacation = struct
+    let jsont = Proto.Vacation.jsont
+  end
+
+  module Blob = struct
+    let upload_response_jsont = Proto.Blob.upload_response_jsont
+  end
+
+  module Method = struct
+    let get_response_jsont = Proto.Method.get_response_jsont
+    let query_response_jsont = Proto.Method.query_response_jsont
+    let changes_response_jsont = Proto.Method.changes_response_jsont
+    let set_response_jsont = Proto.Method.set_response_jsont
+  end
+
+  module Mail_filter = struct
+    let email_filter_jsont = Proto.Mail_filter.email_filter_jsont
+    let mailbox_filter_jsont = Proto.Mail_filter.mailbox_filter_jsont
+    let submission_filter_jsont = Proto.Mail_filter.submission_filter_jsont
+  end
+
+  module Filter = struct
+    let comparator_jsont = Proto.Filter.comparator_jsont
+  end
+end

lib/core/jmap.mli

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+(** Unified JMAP interface for OCaml
+
+    This module provides a clean, ergonomic API for working with JMAP
+    (RFC 8620/8621), combining the protocol and mail layers with abstract
+    types and polymorphic variants.
+
+    {2 Quick Start}
+
+    {[
+      open Jmap
+
+      (* Keywords use polymorphic variants *)
+      let is_unread email =
+        not (List.mem `Seen (Email.keywords email))
+
+      (* Mailbox roles are also polymorphic *)
+      let find_inbox mailboxes =
+        List.find_opt (fun m -> Mailbox.role m = Some `Inbox) mailboxes
+    ]}
+
+    {2 Module Structure}
+
+    - {!Proto} - Low-level protocol and mail types (RFC 8620/8621)
+    - {!Error}, {!Id}, {!Keyword}, {!Role}, {!Capability} - Core types
+    - {!Session}, {!Email}, {!Mailbox}, etc. - Abstract type accessors
+*)
+
+(** {1 Protocol Layer Re-exports} *)
+
+(** Low-level JMAP protocol types (RFC 8620/8621).
+
+    These are the raw protocol and mail types. For most use cases, prefer the
+    higher-level types in this module. *)
+module Proto = Jmap_proto
+
+(** {1 Core Types} *)
+
+(** Unified error type for JMAP operations. *)
+module Error : sig
+  (** Request-level error (RFC 7807 Problem Details). *)
+  type request = {
+    type_ : string;
+    status : int option;
+    title : string option;
+    detail : string option;
+    limit : string option;
+  }
+
+  (** Method-level error. *)
+  type method_ = {
+    type_ : string;
+    description : string option;
+  }
+
+  (** Set operation error for a specific object. *)
+  type set = {
+    type_ : string;
+    description : string option;
+    properties : string list option;
+  }
+
+  (** Unified error type.
+
+      All errors from JSON parsing, HTTP, session management, and JMAP method
+      calls are represented as polymorphic variants. *)
+  type t = [
+    | `Request of request
+    | `Method of method_
+    | `Set of string * set
+    | `Json of string
+    | `Http of int * string
+    | `Connection of string
+    | `Session of string
+  ]
+
+  val pp : Format.formatter -> t -> unit
+  val to_string : t -> string
+end
+
+(** JMAP identifier type. *)
+module Id : sig
+  type t
+
+  val of_string : string -> (t, string) result
+  val of_string_exn : string -> t
+  val to_string : t -> string
+  val compare : t -> t -> int
+  val equal : t -> t -> bool
+  val pp : Format.formatter -> t -> unit
+end
+
+(** Email keyword type.
+
+    Standard keywords are represented as polymorphic variants.
+    Custom keywords use [`Custom of string]. *)
+module Keyword : sig
+  type t = [
+    | `Seen
+    | `Flagged
+    | `Answered
+    | `Draft
+    | `Forwarded
+    | `Phishing
+    | `Junk
+    | `NotJunk
+    | `Custom of string
+  ]
+
+  val of_string : string -> t
+  val to_string : t -> string
+  val pp : Format.formatter -> t -> unit
+end
+
+(** Mailbox role type.
+
+    Standard roles are represented as polymorphic variants.
+    Custom roles use [`Custom of string]. *)
+module Role : sig
+  type t = [
+    | `Inbox
+    | `Sent
+    | `Drafts
+    | `Trash
+    | `Junk
+    | `Archive
+    | `Flagged
+    | `Important
+    | `All
+    | `Subscribed
+    | `Custom of string
+  ]
+
+  val of_string : string -> t
+  val to_string : t -> string
+  val pp : Format.formatter -> t -> unit
+end
+
+(** JMAP capability type.
+
+    Standard capabilities are represented as polymorphic variants.
+    Custom capabilities use [`Custom of string]. *)
+module Capability : sig
+  type t = [
+    | `Core
+    | `Mail
+    | `Submission
+    | `VacationResponse
+    | `Custom of string
+  ]
+
+  val core_uri : string
+  val mail_uri : string
+  val submission_uri : string
+  val vacation_uri : string
+
+  val of_string : string -> t
+  val to_string : t -> string
+  val pp : Format.formatter -> t -> unit
+end
+
+(** {1 Session Types} *)
+
+(** JMAP session information. *)
+module Session : sig
+  (** Account information. *)
+  module Account : sig
+    type t
+
+    val name : t -> string
+    val is_personal : t -> bool
+    val is_read_only : t -> bool
+  end
+
+  type t
+
+  val capabilities : t -> (string * Jsont.json) list
+  val accounts : t -> (Id.t * Account.t) list
+  val primary_accounts : t -> (string * Id.t) list
+  val username : t -> string
+  val api_url : t -> string
+  val download_url : t -> string
+  val upload_url : t -> string
+  val event_source_url : t -> string
+  val state : t -> string
+
+  val get_account : Id.t -> t -> Account.t option
+  val primary_account_for : string -> t -> Id.t option
+  val has_capability : string -> t -> bool
+end
+
+(** {1 Mail Types} *)
+
+(** Email address with optional display name. *)
+module Email_address : sig
+  type t
+
+  val name : t -> string option
+  val email : t -> string
+  val create : ?name:string -> string -> t
+end
+
+(** Email mailbox. *)
+module Mailbox : sig
+  type t
+
+  val id : t -> Id.t
+  val name : t -> string
+  val parent_id : t -> Id.t option
+  val sort_order : t -> int64
+  val total_emails : t -> int64
+  val unread_emails : t -> int64
+  val total_threads : t -> int64
+  val unread_threads : t -> int64
+  val is_subscribed : t -> bool
+  val role : t -> Role.t option
+
+  (** Mailbox rights. *)
+  module Rights : sig
+    type t
+
+    val may_read_items : t -> bool
+    val may_add_items : t -> bool
+    val may_remove_items : t -> bool
+    val may_set_seen : t -> bool
+    val may_set_keywords : t -> bool
+    val may_create_child : t -> bool
+    val may_rename : t -> bool
+    val may_delete : t -> bool
+    val may_submit : t -> bool
+  end
+
+  val my_rights : t -> Rights.t
+end
+
+(** Email thread. *)
+module Thread : sig
+  type t
+
+  val id : t -> Id.t
+  val email_ids : t -> Id.t list
+end
+
+(** Email message. *)
+module Email : sig
+  (** Email body part. *)
+  module Body : sig
+    type part
+    type value
+
+    val part_id : part -> string option
+    val blob_id : part -> Id.t option
+    val size : part -> int64 option
+    val name : part -> string option
+    val type_ : part -> string
+    val charset : part -> string option
+    val disposition : part -> string option
+    val cid : part -> string option
+    val language : part -> string list option
+    val location : part -> string option
+
+    val value_text : value -> string
+    val value_is_truncated : value -> bool
+    val value_is_encoding_problem : value -> bool
+  end
+
+  type t
+
+  val id : t -> Id.t
+  val blob_id : t -> Id.t
+  val thread_id : t -> Id.t
+  val mailbox_ids : t -> (Id.t * bool) list
+  val size : t -> int64
+  val received_at : t -> Ptime.t
+  val message_id : t -> string list option
+  val in_reply_to : t -> string list option
+  val references : t -> string list option
+  val subject : t -> string option
+  val sent_at : t -> Ptime.t option
+  val has_attachment : t -> bool
+  val preview : t -> string
+
+  (** Get active keywords as polymorphic variants. *)
+  val keywords : t -> Keyword.t list
+
+  (** Check if email has a specific keyword. *)
+  val has_keyword : Keyword.t -> t -> bool
+
+  val from : t -> Email_address.t list option
+  val to_ : t -> Email_address.t list option
+  val cc : t -> Email_address.t list option
+  val bcc : t -> Email_address.t list option
+  val reply_to : t -> Email_address.t list option
+  val sender : t -> Email_address.t list option
+
+  val text_body : t -> Body.part list option
+  val html_body : t -> Body.part list option
+  val attachments : t -> Body.part list option
+  val body_values : t -> (string * Body.value) list option
+end
+
+(** Email identity for sending. *)
+module Identity : sig
+  type t
+
+  val id : t -> Id.t
+  val name : t -> string
+  val email : t -> string
+  val reply_to : t -> Email_address.t list option
+  val bcc : t -> Email_address.t list option
+  val text_signature : t -> string
+  val html_signature : t -> string
+  val may_delete : t -> bool
+end
+
+(** Email submission for outgoing mail. *)
+module Submission : sig
+  type t
+
+  val id : t -> Id.t
+  val identity_id : t -> Id.t
+  val email_id : t -> Id.t
+  val thread_id : t -> Id.t
+  val send_at : t -> Ptime.t
+  val undo_status : t -> Proto.Submission.undo_status
+  val delivery_status : t -> (string * Proto.Submission.Delivery_status.t) list option
+  val dsn_blob_ids : t -> Id.t list
+  val mdn_blob_ids : t -> Id.t list
+end
+
+(** Vacation auto-response. *)
+module Vacation : sig
+  type t
+
+  val id : t -> Id.t
+  val is_enabled : t -> bool
+  val from_date : t -> Ptime.t option
+  val to_date : t -> Ptime.t option
+  val subject : t -> string option
+  val text_body : t -> string option
+  val html_body : t -> string option
+end
+
+(** Search snippet with highlighted matches. *)
+module Search_snippet : sig
+  type t
+
+  val email_id : t -> Id.t
+  val subject : t -> string option
+  val preview : t -> string option
+end
+
+(** {1 Filter Types} *)
+
+(** Email filter conditions for queries. *)
+module Email_filter : sig
+  type condition
+
+  (** Create an email filter condition.
+
+      All parameters are optional. Omitted parameters are not included
+      in the filter. Use [make ()] for an empty filter. *)
+  val make :
+    ?in_mailbox:Id.t ->
+    ?in_mailbox_other_than:Id.t list ->
+    ?before:Ptime.t ->
+    ?after:Ptime.t ->
+    ?min_size:int64 ->
+    ?max_size:int64 ->
+    ?all_in_thread_have_keyword:Keyword.t ->
+    ?some_in_thread_have_keyword:Keyword.t ->
+    ?none_in_thread_have_keyword:Keyword.t ->
+    ?has_keyword:Keyword.t ->
+    ?not_keyword:Keyword.t ->
+    ?has_attachment:bool ->
+    ?text:string ->
+    ?from:string ->
+    ?to_:string ->
+    ?cc:string ->
+    ?bcc:string ->
+    ?subject:string ->
+    ?body:string ->
+    ?header:(string * string option) ->
+    unit -> condition
+end
+
+(** Mailbox filter conditions for queries. *)
+module Mailbox_filter : sig
+  type condition
+
+  (** Create a mailbox filter condition.
+
+      All parameters are optional.
+      For [role]: [Some (Some r)] filters by role [r], [Some None] filters for
+      mailboxes with no role, [None] doesn't filter by role. *)
+  val make :
+    ?parent_id:Id.t option ->
+    ?name:string ->
+    ?role:Role.t option ->
+    ?has_any_role:bool ->
+    ?is_subscribed:bool ->
+    unit -> condition
+end
+
+(** {1 Response Types} *)
+
+(** Generic /get response wrapper. *)
+module Get_response : sig
+  type 'a t
+
+  val account_id : 'a t -> Id.t
+  val state : 'a t -> string
+  val list : 'a t -> 'a list
+  val not_found : 'a t -> Id.t list
+end
+
+(** Query response. *)
+module Query_response : sig
+  type t
+
+  val account_id : t -> Id.t
+  val query_state : t -> string
+  val can_calculate_changes : t -> bool
+  val position : t -> int64
+  val ids : t -> Id.t list
+  val total : t -> int64 option
+end
+
+(** Changes response. *)
+module Changes_response : sig
+  type t
+
+  val account_id : t -> Id.t
+  val old_state : t -> string
+  val new_state : t -> string
+  val has_more_changes : t -> bool
+  val created : t -> Id.t list
+  val updated : t -> Id.t list
+  val destroyed : t -> Id.t list
+end
+
+(** {1 JSONABLE Interface} *)
+
+(** Module type for types that can be serialized to/from JSON bytes. *)
+module type JSONABLE = sig
+  type t
+
+  val of_string : string -> (t, Error.t) result
+  val to_string : t -> (string, Error.t) result
+end
+
+(** {1 Private Interface} *)
+
+(** Private module for internal use by Jmap_eio.
+
+    This exposes the underlying Jsont codecs for serialization. *)
+module Private : sig
+  module Session : sig
+    val jsont : Proto.Session.t Jsont.t
+  end
+
+  module Request : sig
+    val jsont : Proto.Request.t Jsont.t
+  end
+
+  module Response : sig
+    val jsont : Proto.Response.t Jsont.t
+  end
+
+  module Mailbox : sig
+    val jsont : Proto.Mailbox.t Jsont.t
+  end
+
+  module Email : sig
+    val jsont : Proto.Email.t Jsont.t
+  end
+
+  module Thread : sig
+    val jsont : Proto.Thread.t Jsont.t
+  end
+
+  module Identity : sig
+    val jsont : Proto.Identity.t Jsont.t
+  end
+
+  module Submission : sig
+    val jsont : Proto.Submission.t Jsont.t
+  end
+
+  module Vacation : sig
+    val jsont : Proto.Vacation.t Jsont.t
+  end
+
+  module Blob : sig
+    val upload_response_jsont : Proto.Blob.upload_response Jsont.t
+  end
+
+  module Method : sig
+    val get_response_jsont : 'a Jsont.t -> 'a Proto.Method.get_response Jsont.t
+    val query_response_jsont : Proto.Method.query_response Jsont.t
+    val changes_response_jsont : Proto.Method.changes_response Jsont.t
+    val set_response_jsont : 'a Jsont.t -> 'a Proto.Method.set_response Jsont.t
+  end
+
+  module Mail_filter : sig
+    val email_filter_jsont : Proto.Mail_filter.email_filter Jsont.t
+    val mailbox_filter_jsont : Proto.Mail_filter.mailbox_filter Jsont.t
+    val submission_filter_jsont : Proto.Mail_filter.submission_filter Jsont.t
+  end
+
+  module Filter : sig
+    val comparator_jsont : Proto.Filter.comparator Jsont.t
+  end
+end

lib/core/jmap_types.ml

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+(** Internal types for the unified Jmap interface *)
+
+(** {1 Error Types} *)
+
+module Error = struct
+  (** Request-level error (RFC 7807 Problem Details) *)
+  type request = {
+    type_ : string;
+    status : int option;
+    title : string option;
+    detail : string option;
+    limit : string option;
+  }
+
+  (** Method-level error *)
+  type method_ = {
+    type_ : string;
+    description : string option;
+  }
+
+  (** Set operation error for a specific object *)
+  type set = {
+    type_ : string;
+    description : string option;
+    properties : string list option;
+  }
+
+  (** Unified error type *)
+  type t = [
+    | `Request of request
+    | `Method of method_
+    | `Set of string * set
+    | `Json of string
+    | `Http of int * string
+    | `Connection of string
+    | `Session of string
+  ]
+
+  let pp_request ppf (r : request) =
+    Format.fprintf ppf "Request error: %s" r.type_;
+    Option.iter (Format.fprintf ppf " (status %d)") r.status;
+    Option.iter (Format.fprintf ppf ": %s") r.detail
+
+  let pp_method ppf (m : method_) =
+    Format.fprintf ppf "Method error: %s" m.type_;
+    Option.iter (Format.fprintf ppf ": %s") m.description
+
+  let pp_set ppf (id, (s : set)) =
+    Format.fprintf ppf "Set error for %s: %s" id s.type_;
+    Option.iter (Format.fprintf ppf ": %s") s.description
+
+  let pp ppf = function
+    | `Request r -> pp_request ppf r
+    | `Method m -> pp_method ppf m
+    | `Set (id, s) -> pp_set ppf (id, s)
+    | `Json msg -> Format.fprintf ppf "JSON error: %s" msg
+    | `Http (code, msg) -> Format.fprintf ppf "HTTP error %d: %s" code msg
+    | `Connection msg -> Format.fprintf ppf "Connection error: %s" msg
+    | `Session msg -> Format.fprintf ppf "Session error: %s" msg
+
+  let to_string e = Format.asprintf "%a" pp e
+end
+
+(** {1 Identifier Type} *)
+
+module Id = struct
+  type t = Jmap_proto.Id.t
+
+  let of_string s = Jmap_proto.Id.of_string s
+  let of_string_exn s = Jmap_proto.Id.of_string_exn s
+  let to_string = Jmap_proto.Id.to_string
+  let compare = Jmap_proto.Id.compare
+  let equal = Jmap_proto.Id.equal
+  let pp = Jmap_proto.Id.pp
+end
+
+(** {1 Keyword Type} *)
+
+module Keyword = struct
+  type t = [
+    | `Seen
+    | `Flagged
+    | `Answered
+    | `Draft
+    | `Forwarded
+    | `Phishing
+    | `Junk
+    | `NotJunk
+    | `Custom of string
+  ]
+
+  let of_string = function
+    | "$seen" -> `Seen
+    | "$flagged" -> `Flagged
+    | "$answered" -> `Answered
+    | "$draft" -> `Draft
+    | "$forwarded" -> `Forwarded
+    | "$phishing" -> `Phishing
+    | "$junk" -> `Junk
+    | "$notjunk" -> `NotJunk
+    | s -> `Custom s
+
+  let to_string = function
+    | `Seen -> "$seen"
+    | `Flagged -> "$flagged"
+    | `Answered -> "$answered"
+    | `Draft -> "$draft"
+    | `Forwarded -> "$forwarded"
+    | `Phishing -> "$phishing"
+    | `Junk -> "$junk"
+    | `NotJunk -> "$notjunk"
+    | `Custom s -> s
+
+  let pp ppf k = Format.pp_print_string ppf (to_string k)
+end
+
+(** {1 Mailbox Role Type} *)
+
+module Role = struct
+  type t = [
+    | `Inbox
+    | `Sent
+    | `Drafts
+    | `Trash
+    | `Junk
+    | `Archive
+    | `Flagged
+    | `Important
+    | `All
+    | `Subscribed
+    | `Custom of string
+  ]
+
+  let of_string = function
+    | "inbox" -> `Inbox
+    | "sent" -> `Sent
+    | "drafts" -> `Drafts
+    | "trash" -> `Trash
+    | "junk" -> `Junk
+    | "archive" -> `Archive
+    | "flagged" -> `Flagged
+    | "important" -> `Important
+    | "all" -> `All
+    | "subscribed" -> `Subscribed
+    | s -> `Custom s
+
+  let to_string = function
+    | `Inbox -> "inbox"
+    | `Sent -> "sent"
+    | `Drafts -> "drafts"
+    | `Trash -> "trash"
+    | `Junk -> "junk"
+    | `Archive -> "archive"
+    | `Flagged -> "flagged"
+    | `Important -> "important"
+    | `All -> "all"
+    | `Subscribed -> "subscribed"
+    | `Custom s -> s
+
+  let pp ppf r = Format.pp_print_string ppf (to_string r)
+end
+
+(** {1 Capability Type} *)
+
+module Capability = struct
+  type t = [
+    | `Core
+    | `Mail
+    | `Submission
+    | `VacationResponse
+    | `Custom of string
+  ]
+
+  let core_uri = "urn:ietf:params:jmap:core"
+  let mail_uri = "urn:ietf:params:jmap:mail"
+  let submission_uri = "urn:ietf:params:jmap:submission"
+  let vacation_uri = "urn:ietf:params:jmap:vacationresponse"
+
+  let of_string = function
+    | s when s = core_uri -> `Core
+    | s when s = mail_uri -> `Mail
+    | s when s = submission_uri -> `Submission
+    | s when s = vacation_uri -> `VacationResponse
+    | s -> `Custom s
+
+  let to_string = function
+    | `Core -> core_uri
+    | `Mail -> mail_uri
+    | `Submission -> submission_uri
+    | `VacationResponse -> vacation_uri
+    | `Custom s -> s
+
+  let pp ppf c = Format.pp_print_string ppf (to_string c)
+end
+
+(** {1 Abstract Type Wrappers} *)
+
+(** Wrapped session type *)
+type session = Jmap_proto.Session.t
+
+(** Wrapped account type *)
+type account = Jmap_proto.Session.Account.t
+
+(** Wrapped mailbox type *)
+type mailbox = Jmap_proto.Mailbox.t
+
+(** Wrapped email type *)
+type email = Jmap_proto.Email.t
+
+(** Wrapped thread type *)
+type thread = Jmap_proto.Thread.t
+
+(** Wrapped identity type *)
+type identity = Jmap_proto.Identity.t
+
+(** Wrapped email submission type *)
+type submission = Jmap_proto.Submission.t
+
+(** Wrapped vacation response type *)
+type vacation = Jmap_proto.Vacation.t
+
+(** Wrapped email address type *)
+type email_address = Jmap_proto.Email_address.t
+
+(** Wrapped search snippet type *)
+type search_snippet = Jmap_proto.Search_snippet.t

lib/dune

···
+(include_subdirs unqualified)
+
+(library
+ (name jmap)
+ (public_name jmap)
+ (libraries jsont json-pointer ptime)
+ (modules
+  ; Core unified interface
+  jmap
+  jmap_types
+  ; Protocol layer wrapper (combines core + mail)
+  jmap_proto
+  ; Core protocol modules
+  proto_id
+  proto_int53
+  proto_date
+  proto_json_map
+  proto_unknown
+  proto_error
+  proto_capability
+  proto_filter
+  proto_method
+  proto_invocation
+  proto_request
+  proto_response
+  proto_session
+  proto_push
+  proto_blob
+  ; Mail modules
+  mail_address
+  mail_header
+  mail_body
+  mail_mailbox
+  mail_thread
+  mail_email
+  mail_snippet
+  mail_identity
+  mail_submission
+  mail_vacation
+  mail_filter))

lib/mail/mail_filter.ml

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+type email_filter = Mail_email.Filter_condition.t Proto_filter.filter
+
+let email_filter_jsont = Proto_filter.filter_jsont Mail_email.Filter_condition.jsont
+
+type mailbox_filter = Mail_mailbox.Filter_condition.t Proto_filter.filter
+
+let mailbox_filter_jsont = Proto_filter.filter_jsont Mail_mailbox.Filter_condition.jsont
+
+type submission_filter = Mail_submission.Filter_condition.t Proto_filter.filter
+
+let submission_filter_jsont = Proto_filter.filter_jsont Mail_submission.Filter_condition.jsont

lib/proto/jmap_proto.ml

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+(** JMAP Protocol Types (RFC 8620/8621)
+
+    This module re-exports all JMAP core and mail protocol types. *)
+
+(** {1 Core Protocol Types (RFC 8620)} *)
+
+module Id = Proto_id
+module Int53 = Proto_int53
+module Date = Proto_date
+module Json_map = Proto_json_map
+module Unknown = Proto_unknown
+module Error = Proto_error
+module Capability = Proto_capability
+module Filter = Proto_filter
+module Method = Proto_method
+module Invocation = Proto_invocation
+module Request = Proto_request
+module Response = Proto_response
+module Session = Proto_session
+module Push = Proto_push
+module Blob = Proto_blob
+
+(** {1 Mail Types (RFC 8621)} *)
+
+module Email_address = Mail_address
+module Email_header = Mail_header
+module Email_body = Mail_body
+module Mailbox = Mail_mailbox
+module Thread = Mail_thread
+module Email = Mail_email
+module Search_snippet = Mail_snippet
+module Identity = Mail_identity
+module Submission = Mail_submission
+module Vacation = Mail_vacation
+module Mail_filter = Mail_filter

lib/proto/proto_method.ml

···
+(*---------------------------------------------------------------------------
+   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
+   SPDX-License-Identifier: ISC
+  ---------------------------------------------------------------------------*)
+
+(* Foo/get *)
+
+type get_args = {
+  account_id : Proto_id.t;
+  ids : Proto_id.t list option;
+  properties : string list option;
+}
+
+let get_args ~account_id ?ids ?properties () =
+  { account_id; ids; properties }
+
+let get_args_make account_id ids properties =
+  { account_id; ids; properties }
+
+let get_args_jsont =
+  let kind = "GetArgs" in
+  Jsont.Object.map ~kind get_args_make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "ids" (Jsont.list Proto_id.jsont) ~enc:(fun a -> a.ids)
+  |> Jsont.Object.opt_mem "properties" (Jsont.list Jsont.string) ~enc:(fun a -> a.properties)
+  |> Jsont.Object.finish
+
+type 'a get_response = {
+  account_id : Proto_id.t;
+  state : string;
+  list : 'a list;
+  not_found : Proto_id.t list;
+}
+
+let get_response_jsont (type a) (obj_jsont : a Jsont.t) : a get_response Jsont.t =
+  let kind = "GetResponse" in
+  let make account_id state list not_found =
+    { account_id; state; list; not_found }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
+  |> Jsont.Object.mem "list" (Jsont.list obj_jsont) ~enc:(fun r -> r.list)
+  |> Jsont.Object.mem "notFound" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.not_found)
+  |> Jsont.Object.finish
+
+(* Foo/changes *)
+
+type changes_args = {
+  account_id : Proto_id.t;
+  since_state : string;
+  max_changes : int64 option;
+}
+
+let changes_args ~account_id ~since_state ?max_changes () =
+  { account_id; since_state; max_changes }
+
+let changes_args_make account_id since_state max_changes =
+  { account_id; since_state; max_changes }
+
+let changes_args_jsont =
+  let kind = "ChangesArgs" in
+  Jsont.Object.map ~kind changes_args_make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.mem "sinceState" Jsont.string ~enc:(fun a -> a.since_state)
+  |> Jsont.Object.opt_mem "maxChanges" Proto_int53.Unsigned.jsont ~enc:(fun a -> a.max_changes)
+  |> Jsont.Object.finish
+
+type changes_response = {
+  account_id : Proto_id.t;
+  old_state : string;
+  new_state : string;
+  has_more_changes : bool;
+  created : Proto_id.t list;
+  updated : Proto_id.t list;
+  destroyed : Proto_id.t list;
+}
+
+let changes_response_make account_id old_state new_state has_more_changes
+    created updated destroyed =
+  { account_id; old_state; new_state; has_more_changes; created; updated; destroyed }
+
+let changes_response_jsont =
+  let kind = "ChangesResponse" in
+  Jsont.Object.map ~kind changes_response_make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
+  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
+  |> Jsont.Object.mem "hasMoreChanges" Jsont.bool ~enc:(fun r -> r.has_more_changes)
+  |> Jsont.Object.mem "created" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.created)
+  |> Jsont.Object.mem "updated" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.updated)
+  |> Jsont.Object.mem "destroyed" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.destroyed)
+  |> Jsont.Object.finish
+
+(* Foo/set *)
+
+type 'a set_args = {
+  account_id : Proto_id.t;
+  if_in_state : string option;
+  create : (Proto_id.t * 'a) list option;
+  update : (Proto_id.t * Jsont.json) list option;
+  destroy : Proto_id.t list option;
+}
+
+let set_args ~account_id ?if_in_state ?create ?update ?destroy () =
+  { account_id; if_in_state; create; update; destroy }
+
+let set_args_jsont (type a) (obj_jsont : a Jsont.t) : a set_args Jsont.t =
+  let kind = "SetArgs" in
+  let make account_id if_in_state create update destroy =
+    { account_id; if_in_state; create; update; destroy }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "ifInState" Jsont.string ~enc:(fun a -> a.if_in_state)
+  |> Jsont.Object.opt_mem "create" (Proto_json_map.of_id obj_jsont) ~enc:(fun a -> a.create)
+  |> Jsont.Object.opt_mem "update" (Proto_json_map.of_id Jsont.json) ~enc:(fun a -> a.update)
+  |> Jsont.Object.opt_mem "destroy" (Jsont.list Proto_id.jsont) ~enc:(fun a -> a.destroy)
+  |> Jsont.Object.finish
+
+type 'a set_response = {
+  account_id : Proto_id.t;
+  old_state : string option;
+  new_state : string;
+  created : (Proto_id.t * 'a) list option;
+  updated : (Proto_id.t * 'a option) list option;
+  destroyed : Proto_id.t list option;
+  not_created : (Proto_id.t * Proto_error.set_error) list option;
+  not_updated : (Proto_id.t * Proto_error.set_error) list option;
+  not_destroyed : (Proto_id.t * Proto_error.set_error) list option;
+}
+
+let set_response_jsont (type a) (obj_jsont : a Jsont.t) : a set_response Jsont.t =
+  let kind = "SetResponse" in
+  let make account_id old_state new_state created updated destroyed
+      not_created not_updated not_destroyed =
+    { account_id; old_state; new_state; created; updated; destroyed;
+      not_created; not_updated; not_destroyed }
+  in
+  (* For updated values, the server may return null or an object - RFC 8620 Section 5.3 *)
+  (* "Id[Foo|null]" means map values can be null, use Jsont.option to handle this *)
+  let nullable_obj = Jsont.(option obj_jsont) in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.opt_mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
+  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
+  |> Jsont.Object.opt_mem "created" (Proto_json_map.of_id obj_jsont) ~enc:(fun r -> r.created)
+  |> Jsont.Object.opt_mem "updated" (Proto_json_map.of_id nullable_obj) ~enc:(fun r -> r.updated)
+  |> Jsont.Object.opt_mem "destroyed" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.destroyed)
+  |> Jsont.Object.opt_mem "notCreated" (Proto_json_map.of_id Proto_error.set_error_jsont) ~enc:(fun r -> r.not_created)
+  |> Jsont.Object.opt_mem "notUpdated" (Proto_json_map.of_id Proto_error.set_error_jsont) ~enc:(fun r -> r.not_updated)
+  |> Jsont.Object.opt_mem "notDestroyed" (Proto_json_map.of_id Proto_error.set_error_jsont) ~enc:(fun r -> r.not_destroyed)
+  |> Jsont.Object.finish
+
+(* Foo/copy *)
+
+type 'a copy_args = {
+  from_account_id : Proto_id.t;
+  if_from_in_state : string option;
+  account_id : Proto_id.t;
+  if_in_state : string option;
+  create : (Proto_id.t * 'a) list;
+  on_success_destroy_original : bool;
+  destroy_from_if_in_state : string option;
+}
+
+let copy_args_jsont (type a) (obj_jsont : a Jsont.t) : a copy_args Jsont.t =
+  let kind = "CopyArgs" in
+  let make from_account_id if_from_in_state account_id if_in_state create
+      on_success_destroy_original destroy_from_if_in_state =
+    { from_account_id; if_from_in_state; account_id; if_in_state; create;
+      on_success_destroy_original; destroy_from_if_in_state }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "fromAccountId" Proto_id.jsont ~enc:(fun a -> a.from_account_id)
+  |> Jsont.Object.opt_mem "ifFromInState" Jsont.string ~enc:(fun a -> a.if_from_in_state)
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "ifInState" Jsont.string ~enc:(fun a -> a.if_in_state)
+  |> Jsont.Object.mem "create" (Proto_json_map.of_id obj_jsont) ~enc:(fun a -> a.create)
+  |> Jsont.Object.mem "onSuccessDestroyOriginal" Jsont.bool ~dec_absent:false
+       ~enc:(fun a -> a.on_success_destroy_original)
+       ~enc_omit:(fun b -> not b)
+  |> Jsont.Object.opt_mem "destroyFromIfInState" Jsont.string ~enc:(fun a -> a.destroy_from_if_in_state)
+  |> Jsont.Object.finish
+
+type 'a copy_response = {
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
+  old_state : string option;
+  new_state : string;
+  created : (Proto_id.t * 'a) list option;
+  not_created : (Proto_id.t * Proto_error.set_error) list option;
+}
+
+let copy_response_jsont (type a) (obj_jsont : a Jsont.t) : a copy_response Jsont.t =
+  let kind = "CopyResponse" in
+  let make from_account_id account_id old_state new_state created not_created =
+    { from_account_id; account_id; old_state; new_state; created; not_created }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "fromAccountId" Proto_id.jsont ~enc:(fun r -> r.from_account_id)
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.opt_mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
+  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
+  |> Jsont.Object.opt_mem "created" (Proto_json_map.of_id obj_jsont) ~enc:(fun r -> r.created)
+  |> Jsont.Object.opt_mem "notCreated" (Proto_json_map.of_id Proto_error.set_error_jsont) ~enc:(fun r -> r.not_created)
+  |> Jsont.Object.finish
+
+(* Foo/query *)
+
+type 'filter query_args = {
+  account_id : Proto_id.t;
+  filter : 'filter Proto_filter.filter option;
+  sort : Proto_filter.comparator list option;
+  position : int64;
+  anchor : Proto_id.t option;
+  anchor_offset : int64;
+  limit : int64 option;
+  calculate_total : bool;
+}
+
+let query_args ~account_id ?filter ?sort ?(position = 0L) ?anchor
+    ?(anchor_offset = 0L) ?limit ?(calculate_total = false) () =
+  { account_id; filter; sort; position; anchor; anchor_offset; limit; calculate_total }
+
+let query_args_jsont (type f) (filter_cond_jsont : f Jsont.t) : f query_args Jsont.t =
+  let kind = "QueryArgs" in
+  let make account_id filter sort position anchor anchor_offset limit calculate_total =
+    { account_id; filter; sort; position; anchor; anchor_offset; limit; calculate_total }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "filter" (Proto_filter.filter_jsont filter_cond_jsont) ~enc:(fun a -> a.filter)
+  |> Jsont.Object.opt_mem "sort" (Jsont.list Proto_filter.comparator_jsont) ~enc:(fun a -> a.sort)
+  |> Jsont.Object.mem "position" Proto_int53.Signed.jsont ~dec_absent:0L ~enc:(fun a -> a.position)
+       ~enc_omit:(fun p -> p = 0L)
+  |> Jsont.Object.opt_mem "anchor" Proto_id.jsont ~enc:(fun a -> a.anchor)
+  |> Jsont.Object.mem "anchorOffset" Proto_int53.Signed.jsont ~dec_absent:0L ~enc:(fun a -> a.anchor_offset)
+       ~enc_omit:(fun o -> o = 0L)
+  |> Jsont.Object.opt_mem "limit" Proto_int53.Unsigned.jsont ~enc:(fun a -> a.limit)
+  |> Jsont.Object.mem "calculateTotal" Jsont.bool ~dec_absent:false ~enc:(fun a -> a.calculate_total)
+       ~enc_omit:(fun b -> not b)
+  |> Jsont.Object.finish
+
+type query_response = {
+  account_id : Proto_id.t;
+  query_state : string;
+  can_calculate_changes : bool;
+  position : int64;
+  ids : Proto_id.t list;
+  total : int64 option;
+}
+
+let query_response_make account_id query_state can_calculate_changes position ids total =
+  { account_id; query_state; can_calculate_changes; position; ids; total }
+
+let query_response_jsont =
+  let kind = "QueryResponse" in
+  Jsont.Object.map ~kind query_response_make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.mem "queryState" Jsont.string ~enc:(fun r -> r.query_state)
+  |> Jsont.Object.mem "canCalculateChanges" Jsont.bool ~enc:(fun r -> r.can_calculate_changes)
+  |> Jsont.Object.mem "position" Proto_int53.Unsigned.jsont ~enc:(fun r -> r.position)
+  |> Jsont.Object.mem "ids" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.ids)
+  |> Jsont.Object.opt_mem "total" Proto_int53.Unsigned.jsont ~enc:(fun r -> r.total)
+  |> Jsont.Object.finish
+
+(* Foo/queryChanges *)
+
+type 'filter query_changes_args = {
+  account_id : Proto_id.t;
+  filter : 'filter Proto_filter.filter option;
+  sort : Proto_filter.comparator list option;
+  since_query_state : string;
+  max_changes : int64 option;
+  up_to_id : Proto_id.t option;
+  calculate_total : bool;
+}
+
+let query_changes_args_jsont (type f) (filter_cond_jsont : f Jsont.t) : f query_changes_args Jsont.t =
+  let kind = "QueryChangesArgs" in
+  let make account_id filter sort since_query_state max_changes up_to_id calculate_total =
+    { account_id; filter; sort; since_query_state; max_changes; up_to_id; calculate_total }
+  in
+  Jsont.Object.map ~kind make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "filter" (Proto_filter.filter_jsont filter_cond_jsont) ~enc:(fun a -> a.filter)
+  |> Jsont.Object.opt_mem "sort" (Jsont.list Proto_filter.comparator_jsont) ~enc:(fun a -> a.sort)
+  |> Jsont.Object.mem "sinceQueryState" Jsont.string ~enc:(fun a -> a.since_query_state)
+  |> Jsont.Object.opt_mem "maxChanges" Proto_int53.Unsigned.jsont ~enc:(fun a -> a.max_changes)
+  |> Jsont.Object.opt_mem "upToId" Proto_id.jsont ~enc:(fun a -> a.up_to_id)
+  |> Jsont.Object.mem "calculateTotal" Jsont.bool ~dec_absent:false ~enc:(fun a -> a.calculate_total)
+       ~enc_omit:(fun b -> not b)
+  |> Jsont.Object.finish
+
+type query_changes_response = {
+  account_id : Proto_id.t;
+  old_query_state : string;
+  new_query_state : string;
+  total : int64 option;
+  removed : Proto_id.t list;
+  added : Proto_filter.added_item list;
+}
+
+let query_changes_response_make account_id old_query_state new_query_state total removed added =
+  { account_id; old_query_state; new_query_state; total; removed; added }
+
+let query_changes_response_jsont =
+  let kind = "QueryChangesResponse" in
+  Jsont.Object.map ~kind query_changes_response_make
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.mem "oldQueryState" Jsont.string ~enc:(fun r -> r.old_query_state)
+  |> Jsont.Object.mem "newQueryState" Jsont.string ~enc:(fun r -> r.new_query_state)
+  |> Jsont.Object.opt_mem "total" Proto_int53.Unsigned.jsont ~enc:(fun r -> r.total)
+  |> Jsont.Object.mem "removed" (Jsont.list Proto_id.jsont) ~enc:(fun r -> r.removed)
+  |> Jsont.Object.mem "added" (Jsont.list Proto_filter.added_item_jsont) ~enc:(fun r -> r.added)
+  |> Jsont.Object.finish

proto/blob.ml lib/proto/proto_blob.ml

···
   ---------------------------------------------------------------------------*)
 
 type upload_response = {
-  account_id : Id.t;
-  blob_id : Id.t;
+  account_id : Proto_id.t;
+  blob_id : Proto_id.t;
   type_ : string;
   size : int64;
 }
···
 let upload_response_jsont =
   let kind = "Upload response" in
   Jsont.Object.map ~kind upload_response_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:upload_response_account_id
-  |> Jsont.Object.mem "blobId" Id.jsont ~enc:upload_response_blob_id
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:upload_response_account_id
+  |> Jsont.Object.mem "blobId" Proto_id.jsont ~enc:upload_response_blob_id
   |> Jsont.Object.mem "type" Jsont.string ~enc:upload_response_type
-  |> Jsont.Object.mem "size" Int53.Unsigned.jsont ~enc:upload_response_size
+  |> Jsont.Object.mem "size" Proto_int53.Unsigned.jsont ~enc:upload_response_size
   |> Jsont.Object.finish
 
 type download_vars = {
-  account_id : Id.t;
-  blob_id : Id.t;
+  account_id : Proto_id.t;
+  blob_id : Proto_id.t;
   type_ : string;
   name : string;
 }
···
         let var = String.sub part 0 j in
         let rest = String.sub part (j + 1) (String.length part - j - 1) in
         let value = match var with
-          | "accountId" -> url_encode (Id.to_string vars.account_id)
-          | "blobId" -> url_encode (Id.to_string vars.blob_id)
+          | "accountId" -> url_encode (Proto_id.to_string vars.account_id)
+          | "blobId" -> url_encode (Proto_id.to_string vars.blob_id)
           | "type" -> url_encode vars.type_
           | "name" -> url_encode vars.name
           | _ -> "{" ^ var ^ "}"
···
   |> String.concat ""
 
 type copy_args = {
-  from_account_id : Id.t;
-  account_id : Id.t;
-  blob_ids : Id.t list;
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
+  blob_ids : Proto_id.t list;
 }
 
 let copy_args_make from_account_id account_id blob_ids =
···
 let copy_args_jsont =
   let kind = "Blob/copy args" in
   Jsont.Object.map ~kind copy_args_make
-  |> Jsont.Object.mem "fromAccountId" Id.jsont ~enc:(fun a -> a.from_account_id)
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.mem "blobIds" (Jsont.list Id.jsont) ~enc:(fun a -> a.blob_ids)
+  |> Jsont.Object.mem "fromAccountId" Proto_id.jsont ~enc:(fun a -> a.from_account_id)
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.mem "blobIds" (Jsont.list Proto_id.jsont) ~enc:(fun a -> a.blob_ids)
   |> Jsont.Object.finish
 
 type copy_response = {
-  from_account_id : Id.t;
-  account_id : Id.t;
-  copied : (Id.t * Id.t) list option;
-  not_copied : (Id.t * Error.set_error) list option;
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
+  copied : (Proto_id.t * Proto_id.t) list option;
+  not_copied : (Proto_id.t * Proto_error.set_error) list option;
 }
 
 let copy_response_make from_account_id account_id copied not_copied =
···
 let copy_response_jsont =
   let kind = "Blob/copy response" in
   Jsont.Object.map ~kind copy_response_make
-  |> Jsont.Object.mem "fromAccountId" Id.jsont ~enc:(fun r -> r.from_account_id)
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.opt_mem "copied" (Json_map.of_id Id.jsont) ~enc:(fun r -> r.copied)
-  |> Jsont.Object.opt_mem "notCopied" (Json_map.of_id Error.set_error_jsont) ~enc:(fun r -> r.not_copied)
+  |> Jsont.Object.mem "fromAccountId" Proto_id.jsont ~enc:(fun r -> r.from_account_id)
+  |> Jsont.Object.mem "accountId" Proto_id.jsont ~enc:(fun r -> r.account_id)
+  |> Jsont.Object.opt_mem "copied" (Proto_json_map.of_id Proto_id.jsont) ~enc:(fun r -> r.copied)
+  |> Jsont.Object.opt_mem "notCopied" (Proto_json_map.of_id Proto_error.set_error_jsont) ~enc:(fun r -> r.not_copied)
   |> Jsont.Object.finish

proto/blob.mli lib/proto/proto_blob.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP blob upload/download types as defined in RFC 8620 Section 6 *)
+(** JMAP blob upload/download types as defined in RFC 8620 Section 6 
+
+    @canonical Jmap.Proto.Blob *)
 
 (** {1 Upload Response} *)
 
 (** Response from a blob upload. *)
 type upload_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   (** The account the blob was uploaded to. *)
-  blob_id : Id.t;
+  blob_id : Proto_id.t;
   (** The server-assigned blob id. *)
   type_ : string;
   (** The media type of the uploaded blob. *)
···
   (** The size in octets. *)
 }
 
-val upload_response_account_id : upload_response -> Id.t
-val upload_response_blob_id : upload_response -> Id.t
+val upload_response_account_id : upload_response -> Proto_id.t
+val upload_response_blob_id : upload_response -> Proto_id.t
 val upload_response_type : upload_response -> string
 val upload_response_size : upload_response -> int64
 
···
 
 (** Variables for the download URL template. *)
 type download_vars = {
-  account_id : Id.t;
-  blob_id : Id.t;
+  account_id : Proto_id.t;
+  blob_id : Proto_id.t;
   type_ : string;
   name : string;
 }
···
 
 (** Arguments for Blob/copy. *)
 type copy_args = {
-  from_account_id : Id.t;
-  account_id : Id.t;
-  blob_ids : Id.t list;
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
+  blob_ids : Proto_id.t list;
 }
 
 val copy_args_jsont : copy_args Jsont.t
 
 (** Response for Blob/copy. *)
 type copy_response = {
-  from_account_id : Id.t;
-  account_id : Id.t;
-  copied : (Id.t * Id.t) list option;
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
+  copied : (Proto_id.t * Proto_id.t) list option;
   (** Map of old blob id to new blob id. *)
-  not_copied : (Id.t * Error.set_error) list option;
+  not_copied : (Proto_id.t * Proto_error.set_error) list option;
   (** Blobs that could not be copied. *)
 }
 

proto/capability.ml lib/proto/proto_capability.ml

···
   let jsont =
     let kind = "Core capability" in
     Jsont.Object.map ~kind make
-    |> Jsont.Object.mem "maxSizeUpload" Int53.Unsigned.jsont ~enc:max_size_upload
+    |> Jsont.Object.mem "maxSizeUpload" Proto_int53.Unsigned.jsont ~enc:max_size_upload
     |> Jsont.Object.mem "maxConcurrentUpload" Jsont.int ~enc:max_concurrent_upload
-    |> Jsont.Object.mem "maxSizeRequest" Int53.Unsigned.jsont ~enc:max_size_request
+    |> Jsont.Object.mem "maxSizeRequest" Proto_int53.Unsigned.jsont ~enc:max_size_request
     |> Jsont.Object.mem "maxConcurrentRequests" Jsont.int ~enc:max_concurrent_requests
     |> Jsont.Object.mem "maxCallsInRequest" Jsont.int ~enc:max_calls_in_request
     |> Jsont.Object.mem "maxObjectsInGet" Jsont.int ~enc:max_objects_in_get
···
   let jsont =
     let kind = "Mail capability" in
     Jsont.Object.map ~kind make
-    |> Jsont.Object.opt_mem "maxMailboxesPerEmail" Int53.Unsigned.jsont ~enc:max_mailboxes_per_email
-    |> Jsont.Object.opt_mem "maxMailboxDepth" Int53.Unsigned.jsont ~enc:max_mailbox_depth
-    |> Jsont.Object.mem "maxSizeMailboxName" Int53.Unsigned.jsont ~enc:max_size_mailbox_name
-    |> Jsont.Object.mem "maxSizeAttachmentsPerEmail" Int53.Unsigned.jsont ~enc:max_size_attachments_per_email
+    |> Jsont.Object.opt_mem "maxMailboxesPerEmail" Proto_int53.Unsigned.jsont ~enc:max_mailboxes_per_email
+    |> Jsont.Object.opt_mem "maxMailboxDepth" Proto_int53.Unsigned.jsont ~enc:max_mailbox_depth
+    |> Jsont.Object.mem "maxSizeMailboxName" Proto_int53.Unsigned.jsont ~enc:max_size_mailbox_name
+    |> Jsont.Object.mem "maxSizeAttachmentsPerEmail" Proto_int53.Unsigned.jsont ~enc:max_size_attachments_per_email
     |> Jsont.Object.mem "emailQuerySortOptions" (Jsont.list Jsont.string) ~enc:email_query_sort_options
     |> Jsont.Object.mem "mayCreateTopLevelMailbox" Jsont.bool ~enc:may_create_top_level_mailbox
     |> Jsont.Object.finish
···
     { max_delayed_send; submission_extensions }
 
   let submission_extensions_jsont =
-    Json_map.of_string (Jsont.list Jsont.string)
+    Proto_json_map.of_string (Jsont.list Jsont.string)
 
   let jsont =
     let kind = "Submission capability" in
     Jsont.Object.map ~kind make
-    |> Jsont.Object.mem "maxDelayedSend" Int53.Unsigned.jsont ~enc:max_delayed_send
+    |> Jsont.Object.mem "maxDelayedSend" Proto_int53.Unsigned.jsont ~enc:max_delayed_send
     |> Jsont.Object.mem "submissionExtensions" submission_extensions_jsont ~enc:submission_extensions
     |> Jsont.Object.finish
 end

proto/capability.mli lib/proto/proto_capability.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP capability types as defined in RFC 8620 Section 2 *)
+(** JMAP capability types as defined in RFC 8620 Section 2 
+
+    @canonical Jmap.Proto.Capability *)
 
 (** {1 Standard Capability URIs} *)
 

proto/date.mli lib/proto/proto_date.mli

···
 
     JMAP uses RFC 3339 formatted date-time strings.
 
-    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.4} RFC 8620 Section 1.4}. *)
+    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.4} RFC 8620 Section 1.4}. 
+
+    @canonical Jmap.Proto.Date *)
 
 (** RFC 3339 date-time.
 

proto/dune

···
-(library
- (name jmap_proto)
- (public_name jmap)
- (libraries jsont json-pointer ptime)
- (modules
-  jmap_proto
-  id
-  int53
-  date
-  json_map
-  unknown
-  error
-  capability
-  filter
-  method_
-  invocation
-  request
-  response
-  session
-  push
-  blob))

proto/error.mli lib/proto/proto_error.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP error types as defined in RFC 8620 Section 3.6.1-3.6.2 *)
+(** JMAP error types as defined in RFC 8620 Section 3.6.1-3.6.2 
+
+    @canonical Jmap.Proto.Error *)
 
 (** {1 Request-Level Errors}
 

proto/filter.ml lib/proto/proto_filter.ml

···
   |> Jsont.Object.finish
 
 type added_item = {
-  id : Id.t;
+  id : Proto_id.t;
   index : int64;
 }
 
···
 let added_item_jsont =
   let kind = "AddedItem" in
   Jsont.Object.map ~kind added_item_make
-  |> Jsont.Object.mem "id" Id.jsont ~enc:added_item_id
-  |> Jsont.Object.mem "index" Int53.Unsigned.jsont ~enc:added_item_index
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:added_item_id
+  |> Jsont.Object.mem "index" Proto_int53.Unsigned.jsont ~enc:added_item_index
   |> Jsont.Object.finish

proto/filter.mli lib/proto/proto_filter.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP filter and sort types as defined in RFC 8620 Section 5.5 *)
+(** JMAP filter and sort types as defined in RFC 8620 Section 5.5 
+
+    @canonical Jmap.Proto.Filter *)
 
 (** {1 Filter Operators} *)
 
···
 
 (** Added entry position in query change results. *)
 type added_item = {
-  id : Id.t;
+  id : Proto_id.t;
   index : int64;
 }
 

proto/id.mli lib/proto/proto_id.mli

···
     An Id is a string of 1-255 octets from the URL-safe base64 alphabet
     (A-Za-z0-9_-), plus the ASCII alphanumeric characters.
 
-    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.2} RFC 8620 Section 1.2}. *)
+    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.2} RFC 8620 Section 1.2}.
+
+    @canonical Jmap.Proto.Id *)
 
 type t
 (** The type of JMAP identifiers. *)

proto/int53.mli lib/proto/proto_int53.mli

···
     IEEE 754 double-precision floating point format without loss of precision.
     The safe range is -2^53+1 to 2^53-1.
 
-    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.3} RFC 8620 Section 1.3}. *)
+    See {{:https://datatracker.ietf.org/doc/html/rfc8620#section-1.3} RFC 8620 Section 1.3}. 
+
+    @canonical Jmap.Proto.Int53 *)
 
 (** 53-bit signed integer.
 

proto/invocation.ml lib/proto/proto_invocation.ml

···
   Jsont.map ~kind ~dec ~enc Jsont.json
 
 let make_get ~method_call_id ~method_name args =
-  let arguments = encode_json_value Method_.get_args_jsont args in
+  let arguments = encode_json_value Proto_method.get_args_jsont args in
   { name = method_name; arguments; method_call_id }
 
 let make_changes ~method_call_id ~method_name args =
-  let arguments = encode_json_value Method_.changes_args_jsont args in
+  let arguments = encode_json_value Proto_method.changes_args_jsont args in
   { name = method_name; arguments; method_call_id }
 
 let make_query (type f) ~method_call_id ~method_name
-    ~(filter_cond_jsont : f Jsont.t) (args : f Method_.query_args) =
-  let arguments = encode_json_value (Method_.query_args_jsont filter_cond_jsont) args in
+    ~(filter_cond_jsont : f Jsont.t) (args : f Proto_method.query_args) =
+  let arguments = encode_json_value (Proto_method.query_args_jsont filter_cond_jsont) args in
   { name = method_name; arguments; method_call_id }

proto/invocation.mli lib/proto/proto_invocation.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP method invocation as defined in RFC 8620 Section 3.2 *)
+(** JMAP method invocation as defined in RFC 8620 Section 3.2 
+
+    @canonical Jmap.Proto.Invocation *)
 
 (** {1 Result References} *)
 
···
 val make_get :
   method_call_id:string ->
   method_name:string ->
-  Method_.get_args ->
+  Proto_method.get_args ->
   t
 (** [make_get ~method_call_id ~method_name args] creates a /get invocation. *)
 
 val make_changes :
   method_call_id:string ->
   method_name:string ->
-  Method_.changes_args ->
+  Proto_method.changes_args ->
   t
 (** [make_changes ~method_call_id ~method_name args] creates a /changes invocation. *)
 
···
   method_call_id:string ->
   method_name:string ->
   filter_cond_jsont:'f Jsont.t ->
-  'f Method_.query_args ->
+  'f Proto_method.query_args ->
   t
 (** [make_query ~method_call_id ~method_name ~filter_cond_jsont args] creates a /query invocation. *)

proto/jmap_proto.ml

···
-(*---------------------------------------------------------------------------
-   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
-   SPDX-License-Identifier: ISC
-  ---------------------------------------------------------------------------*)
-
-(** JMAP Protocol Types (RFC 8620)
-
-    This module re-exports all JMAP core protocol types. *)
-
-module Id = Id
-module Int53 = Int53
-module Date = Date
-module Json_map = Json_map
-module Unknown = Unknown
-module Error = Error
-module Capability = Capability
-module Filter = Filter
-module Method = Method_
-module Invocation = Invocation
-module Request = Request
-module Response = Response
-module Session = Session
-module Push = Push
-module Blob = Blob

proto/json_map.ml lib/proto/proto_json_map.ml

···
   let string_codec = of_string value_jsont in
   let dec pairs =
     List.map (fun (k, v) ->
-      match Id.of_string k with
+      match Proto_id.of_string k with
       | Ok id -> (id, v)
       | Error msg -> Jsont.Error.msgf Jsont.Meta.none "%s: invalid key %s - %s" kind k msg
     ) pairs
   in
   let enc pairs =
-    List.map (fun (id, v) -> (Id.to_string id, v)) pairs
+    List.map (fun (id, v) -> (Proto_id.to_string id, v)) pairs
   in
   Jsont.map ~kind ~dec ~enc string_codec
 

proto/json_map.mli lib/proto/proto_json_map.mli

···
 (** JSON object-as-map codec utilities.
 
     JMAP frequently uses JSON objects as maps with string or Id keys.
-    These codecs convert between JSON objects and OCaml association lists. *)
+    These codecs convert between JSON objects and OCaml association lists. 
+
+    @canonical Jmap.Proto.Json_map *)
 
 val of_string : 'a Jsont.t -> (string * 'a) list Jsont.t
 (** [of_string value_jsont] creates a codec for JSON objects
     used as string-keyed maps. Returns an association list. *)
 
-val of_id : 'a Jsont.t -> (Id.t * 'a) list Jsont.t
+val of_id : 'a Jsont.t -> (Proto_id.t * 'a) list Jsont.t
 (** [of_id value_jsont] creates a codec for JSON objects
     keyed by JMAP identifiers. *)
 
-val id_to_bool : (Id.t * bool) list Jsont.t
+val id_to_bool : (Proto_id.t * bool) list Jsont.t
 (** Codec for Id[Boolean] maps, common in JMAP (e.g., mailboxIds, keywords). *)
 
 val string_to_bool : (string * bool) list Jsont.t

proto/mail/dune

···
-(library
- (name jmap_mail)
- (public_name jmap.mail)
- (libraries jmap jsont ptime)
- (modules
-  jmap_mail
-  email_address
-  email_header
-  email_body
-  mailbox
-  thread
-  email
-  search_snippet
-  identity
-  submission
-  vacation
-  mail_filter))

proto/mail/email.ml lib/mail/mail_email.ml

···
 end
 
 type t = {
-  id : Jmap_proto.Id.t;
-  blob_id : Jmap_proto.Id.t;
-  thread_id : Jmap_proto.Id.t;
+  id : Proto_id.t;
+  blob_id : Proto_id.t;
+  thread_id : Proto_id.t;
   size : int64;
   received_at : Ptime.t;
-  mailbox_ids : (Jmap_proto.Id.t * bool) list;
+  mailbox_ids : (Proto_id.t * bool) list;
   keywords : (string * bool) list;
   message_id : string list option;
   in_reply_to : string list option;
   references : string list option;
-  sender : Email_address.t list option;
-  from : Email_address.t list option;
-  to_ : Email_address.t list option;
-  cc : Email_address.t list option;
-  bcc : Email_address.t list option;
-  reply_to : Email_address.t list option;
+  sender : Mail_address.t list option;
+  from : Mail_address.t list option;
+  to_ : Mail_address.t list option;
+  cc : Mail_address.t list option;
+  bcc : Mail_address.t list option;
+  reply_to : Mail_address.t list option;
   subject : string option;
   sent_at : Ptime.t option;
-  headers : Email_header.t list option;
-  body_structure : Email_body.Part.t option;
-  body_values : (string * Email_body.Value.t) list option;
-  text_body : Email_body.Part.t list option;
-  html_body : Email_body.Part.t list option;
-  attachments : Email_body.Part.t list option;
+  headers : Mail_header.t list option;
+  body_structure : Mail_body.Part.t option;
+  body_values : (string * Mail_body.Value.t) list option;
+  text_body : Mail_body.Part.t list option;
+  html_body : Mail_body.Part.t list option;
+  attachments : Mail_body.Part.t list option;
   has_attachment : bool;
   preview : string;
 }
···
 
 let jsont =
   let kind = "Email" in
-  let body_values_jsont = Jmap_proto.Json_map.of_string Email_body.Value.jsont in
+  let body_values_jsont = Proto_json_map.of_string Mail_body.Value.jsont in
   (* subject can be null per RFC 8621 Section 4.1.1 *)
   let nullable_string = Jsont.(option string) in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
-  |> Jsont.Object.mem "blobId" Jmap_proto.Id.jsont ~enc:blob_id
-  |> Jsont.Object.mem "threadId" Jmap_proto.Id.jsont ~enc:thread_id
-  |> Jsont.Object.mem "size" Jmap_proto.Int53.Unsigned.jsont ~enc:size
-  |> Jsont.Object.mem "receivedAt" Jmap_proto.Date.Utc.jsont ~enc:received_at
-  |> Jsont.Object.mem "mailboxIds" Jmap_proto.Json_map.id_to_bool ~enc:mailbox_ids
-  |> Jsont.Object.mem "keywords" Jmap_proto.Json_map.string_to_bool ~dec_absent:[] ~enc:keywords
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
+  |> Jsont.Object.mem "blobId" Proto_id.jsont ~enc:blob_id
+  |> Jsont.Object.mem "threadId" Proto_id.jsont ~enc:thread_id
+  |> Jsont.Object.mem "size" Proto_int53.Unsigned.jsont ~enc:size
+  |> Jsont.Object.mem "receivedAt" Proto_date.Utc.jsont ~enc:received_at
+  |> Jsont.Object.mem "mailboxIds" Proto_json_map.id_to_bool ~enc:mailbox_ids
+  |> Jsont.Object.mem "keywords" Proto_json_map.string_to_bool ~dec_absent:[] ~enc:keywords
   (* Header fields can be absent or null per RFC 8621 *)
   |> Jsont.Object.mem "messageId" Jsont.(option (list string))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:message_id
···
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:in_reply_to
   |> Jsont.Object.mem "references" Jsont.(option (list string))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:references
-  |> Jsont.Object.mem "sender" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "sender" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:sender
-  |> Jsont.Object.mem "from" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "from" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:from
-  |> Jsont.Object.mem "to" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "to" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:to_
-  |> Jsont.Object.mem "cc" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "cc" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:cc
-  |> Jsont.Object.mem "bcc" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "bcc" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:bcc
-  |> Jsont.Object.mem "replyTo" Jsont.(option (list Email_address.jsont))
+  |> Jsont.Object.mem "replyTo" Jsont.(option (list Mail_address.jsont))
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:reply_to
   |> Jsont.Object.mem "subject" nullable_string
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:subject
-  |> Jsont.Object.opt_mem "sentAt" Jmap_proto.Date.Rfc3339.jsont ~enc:sent_at
-  |> Jsont.Object.opt_mem "headers" (Jsont.list Email_header.jsont) ~enc:headers
-  |> Jsont.Object.opt_mem "bodyStructure" Email_body.Part.jsont ~enc:body_structure
+  |> Jsont.Object.opt_mem "sentAt" Proto_date.Rfc3339.jsont ~enc:sent_at
+  |> Jsont.Object.opt_mem "headers" (Jsont.list Mail_header.jsont) ~enc:headers
+  |> Jsont.Object.opt_mem "bodyStructure" Mail_body.Part.jsont ~enc:body_structure
   |> Jsont.Object.opt_mem "bodyValues" body_values_jsont ~enc:body_values
-  |> Jsont.Object.opt_mem "textBody" (Jsont.list Email_body.Part.jsont) ~enc:text_body
-  |> Jsont.Object.opt_mem "htmlBody" (Jsont.list Email_body.Part.jsont) ~enc:html_body
-  |> Jsont.Object.opt_mem "attachments" (Jsont.list Email_body.Part.jsont) ~enc:attachments
+  |> Jsont.Object.opt_mem "textBody" (Jsont.list Mail_body.Part.jsont) ~enc:text_body
+  |> Jsont.Object.opt_mem "htmlBody" (Jsont.list Mail_body.Part.jsont) ~enc:html_body
+  |> Jsont.Object.opt_mem "attachments" (Jsont.list Mail_body.Part.jsont) ~enc:attachments
   |> Jsont.Object.mem "hasAttachment" Jsont.bool ~dec_absent:false ~enc:has_attachment
   |> Jsont.Object.mem "preview" Jsont.string ~dec_absent:"" ~enc:preview
   |> Jsont.Object.finish
 
 module Filter_condition = struct
   type t = {
-    in_mailbox : Jmap_proto.Id.t option;
-    in_mailbox_other_than : Jmap_proto.Id.t list option;
+    in_mailbox : Proto_id.t option;
+    in_mailbox_other_than : Proto_id.t list option;
     before : Ptime.t option;
     after : Ptime.t option;
     min_size : int64 option;
···
   let jsont =
     let kind = "EmailFilterCondition" in
     Jsont.Object.map ~kind make
-    |> Jsont.Object.opt_mem "inMailbox" Jmap_proto.Id.jsont ~enc:(fun f -> f.in_mailbox)
-    |> Jsont.Object.opt_mem "inMailboxOtherThan" (Jsont.list Jmap_proto.Id.jsont) ~enc:(fun f -> f.in_mailbox_other_than)
-    |> Jsont.Object.opt_mem "before" Jmap_proto.Date.Utc.jsont ~enc:(fun f -> f.before)
-    |> Jsont.Object.opt_mem "after" Jmap_proto.Date.Utc.jsont ~enc:(fun f -> f.after)
-    |> Jsont.Object.opt_mem "minSize" Jmap_proto.Int53.Unsigned.jsont ~enc:(fun f -> f.min_size)
-    |> Jsont.Object.opt_mem "maxSize" Jmap_proto.Int53.Unsigned.jsont ~enc:(fun f -> f.max_size)
+    |> Jsont.Object.opt_mem "inMailbox" Proto_id.jsont ~enc:(fun f -> f.in_mailbox)
+    |> Jsont.Object.opt_mem "inMailboxOtherThan" (Jsont.list Proto_id.jsont) ~enc:(fun f -> f.in_mailbox_other_than)
+    |> Jsont.Object.opt_mem "before" Proto_date.Utc.jsont ~enc:(fun f -> f.before)
+    |> Jsont.Object.opt_mem "after" Proto_date.Utc.jsont ~enc:(fun f -> f.after)
+    |> Jsont.Object.opt_mem "minSize" Proto_int53.Unsigned.jsont ~enc:(fun f -> f.min_size)
+    |> Jsont.Object.opt_mem "maxSize" Proto_int53.Unsigned.jsont ~enc:(fun f -> f.max_size)
     |> Jsont.Object.opt_mem "allInThreadHaveKeyword" Jsont.string ~enc:(fun f -> f.all_in_thread_have_keyword)
     |> Jsont.Object.opt_mem "someInThreadHaveKeyword" Jsont.string ~enc:(fun f -> f.some_in_thread_have_keyword)
     |> Jsont.Object.opt_mem "noneInThreadHaveKeyword" Jsont.string ~enc:(fun f -> f.none_in_thread_have_keyword)
···
        ~enc:(fun a -> a.fetch_html_body_values) ~enc_omit:(fun b -> not b)
   |> Jsont.Object.mem "fetchAllBodyValues" Jsont.bool ~dec_absent:false
        ~enc:(fun a -> a.fetch_all_body_values) ~enc_omit:(fun b -> not b)
-  |> Jsont.Object.opt_mem "maxBodyValueBytes" Jmap_proto.Int53.Unsigned.jsont ~enc:(fun a -> a.max_body_value_bytes)
+  |> Jsont.Object.opt_mem "maxBodyValueBytes" Proto_int53.Unsigned.jsont ~enc:(fun a -> a.max_body_value_bytes)
   |> Jsont.Object.finish

proto/mail/email.mli lib/mail/mail_email.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Email type as defined in RFC 8621 Section 4 *)
+(** Email type as defined in RFC 8621 Section 4 
+
+    @canonical Jmap.Proto.Email *)
 
 (** {1 Standard Keywords} *)
 
···
 
 type t = {
   (* Metadata - server-set, immutable *)
-  id : Jmap_proto.Id.t;
-  blob_id : Jmap_proto.Id.t;
-  thread_id : Jmap_proto.Id.t;
+  id : Proto_id.t;
+  blob_id : Proto_id.t;
+  thread_id : Proto_id.t;
   size : int64;
   received_at : Ptime.t;
 
   (* Metadata - mutable *)
-  mailbox_ids : (Jmap_proto.Id.t * bool) list;
+  mailbox_ids : (Proto_id.t * bool) list;
   keywords : (string * bool) list;
 
   (* Parsed headers *)
   message_id : string list option;
   in_reply_to : string list option;
   references : string list option;
-  sender : Email_address.t list option;
-  from : Email_address.t list option;
-  to_ : Email_address.t list option;
-  cc : Email_address.t list option;
-  bcc : Email_address.t list option;
-  reply_to : Email_address.t list option;
+  sender : Mail_address.t list option;
+  from : Mail_address.t list option;
+  to_ : Mail_address.t list option;
+  cc : Mail_address.t list option;
+  bcc : Mail_address.t list option;
+  reply_to : Mail_address.t list option;
   subject : string option;
   sent_at : Ptime.t option;
 
   (* Raw headers *)
-  headers : Email_header.t list option;
+  headers : Mail_header.t list option;
 
   (* Body structure *)
-  body_structure : Email_body.Part.t option;
-  body_values : (string * Email_body.Value.t) list option;
-  text_body : Email_body.Part.t list option;
-  html_body : Email_body.Part.t list option;
-  attachments : Email_body.Part.t list option;
+  body_structure : Mail_body.Part.t option;
+  body_values : (string * Mail_body.Value.t) list option;
+  text_body : Mail_body.Part.t list option;
+  html_body : Mail_body.Part.t list option;
+  attachments : Mail_body.Part.t list option;
   has_attachment : bool;
   preview : string;
 }
 
-val id : t -> Jmap_proto.Id.t
-val blob_id : t -> Jmap_proto.Id.t
-val thread_id : t -> Jmap_proto.Id.t
+val id : t -> Proto_id.t
+val blob_id : t -> Proto_id.t
+val thread_id : t -> Proto_id.t
 val size : t -> int64
 val received_at : t -> Ptime.t
-val mailbox_ids : t -> (Jmap_proto.Id.t * bool) list
+val mailbox_ids : t -> (Proto_id.t * bool) list
 val keywords : t -> (string * bool) list
 val message_id : t -> string list option
 val in_reply_to : t -> string list option
 val references : t -> string list option
-val sender : t -> Email_address.t list option
-val from : t -> Email_address.t list option
-val to_ : t -> Email_address.t list option
-val cc : t -> Email_address.t list option
-val bcc : t -> Email_address.t list option
-val reply_to : t -> Email_address.t list option
+val sender : t -> Mail_address.t list option
+val from : t -> Mail_address.t list option
+val to_ : t -> Mail_address.t list option
+val cc : t -> Mail_address.t list option
+val bcc : t -> Mail_address.t list option
+val reply_to : t -> Mail_address.t list option
 val subject : t -> string option
 val sent_at : t -> Ptime.t option
-val headers : t -> Email_header.t list option
-val body_structure : t -> Email_body.Part.t option
-val body_values : t -> (string * Email_body.Value.t) list option
-val text_body : t -> Email_body.Part.t list option
-val html_body : t -> Email_body.Part.t list option
-val attachments : t -> Email_body.Part.t list option
+val headers : t -> Mail_header.t list option
+val body_structure : t -> Mail_body.Part.t option
+val body_values : t -> (string * Mail_body.Value.t) list option
+val text_body : t -> Mail_body.Part.t list option
+val html_body : t -> Mail_body.Part.t list option
+val attachments : t -> Mail_body.Part.t list option
 val has_attachment : t -> bool
 val preview : t -> string
 
···
 
 module Filter_condition : sig
   type t = {
-    in_mailbox : Jmap_proto.Id.t option;
-    in_mailbox_other_than : Jmap_proto.Id.t list option;
+    in_mailbox : Proto_id.t option;
+    in_mailbox_other_than : Proto_id.t list option;
     before : Ptime.t option;
     after : Ptime.t option;
     min_size : int64 option;

proto/mail/email_address.mli lib/mail/mail_address.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Email address types as defined in RFC 8621 Section 4.1.2.3 *)
+(** Email address types as defined in RFC 8621 Section 4.1.2.3 
+
+    @canonical Jmap.Proto.Email_address *)
 
 (** {1 Email Address} *)
 

proto/mail/email_body.ml lib/mail/mail_body.ml

···
 module Part = struct
   type t = {
     part_id : string option;
-    blob_id : Jmap_proto.Id.t option;
+    blob_id : Proto_id.t option;
     size : int64 option;
-    headers : Email_header.t list option;
+    headers : Mail_header.t list option;
     name : string option;
     type_ : string;
     charset : string option;
···
     in
     (* Many fields can be null per RFC 8621 Section 4.1.4 *)
     let nullable_string = Jsont.(option string) in
-    let nullable_id = Jsont.(option Jmap_proto.Id.jsont) in
+    let nullable_id = Jsont.(option Proto_id.jsont) in
     lazy (
       Jsont.Object.map ~kind make
       |> Jsont.Object.mem "partId" nullable_string
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:part_id
       |> Jsont.Object.mem "blobId" nullable_id
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:blob_id
-      |> Jsont.Object.opt_mem "size" Jmap_proto.Int53.Unsigned.jsont ~enc:size
-      |> Jsont.Object.opt_mem "headers" (Jsont.list Email_header.jsont) ~enc:headers
+      |> Jsont.Object.opt_mem "size" Proto_int53.Unsigned.jsont ~enc:size
+      |> Jsont.Object.opt_mem "headers" (Jsont.list Mail_header.jsont) ~enc:headers
       |> Jsont.Object.mem "name" nullable_string
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:name
       |> Jsont.Object.mem "type" Jsont.string ~enc:type_

proto/mail/email_body.mli lib/mail/mail_body.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Email body types as defined in RFC 8621 Section 4.1.4 *)
+(** Email body types as defined in RFC 8621 Section 4.1.4 
+
+    @canonical Jmap.Proto.Email_body *)
 
 (** {1 Body Value} *)
 
···
   type t = {
     part_id : string option;
     (** Identifier for this part, used to fetch content. *)
-    blob_id : Jmap_proto.Id.t option;
+    blob_id : Proto_id.t option;
     (** Blob id if the part can be fetched as a blob. *)
     size : int64 option;
     (** Size in octets. *)
-    headers : Email_header.t list option;
+    headers : Mail_header.t list option;
     (** Headers specific to this part. *)
     name : string option;
     (** Suggested filename from Content-Disposition. *)
···
   }
 
   val part_id : t -> string option
-  val blob_id : t -> Jmap_proto.Id.t option
+  val blob_id : t -> Proto_id.t option
   val size : t -> int64 option
-  val headers : t -> Email_header.t list option
+  val headers : t -> Mail_header.t list option
   val name : t -> string option
   val type_ : t -> string
   val charset : t -> string option

proto/mail/email_header.ml lib/mail/mail_header.ml

···
 
 let text_jsont = Jsont.string
 
-let addresses_jsont = Jsont.list Email_address.jsont
+let addresses_jsont = Jsont.list Mail_address.jsont
 
-let grouped_addresses_jsont = Jsont.list Email_address.Group.jsont
+let grouped_addresses_jsont = Jsont.list Mail_address.Group.jsont
 
 let message_ids_jsont = Jsont.list Jsont.string
 
-let date_jsont = Jmap_proto.Date.Rfc3339.jsont
+let date_jsont = Proto_date.Rfc3339.jsont
 
 let urls_jsont = Jsont.list Jsont.string

proto/mail/email_header.mli lib/mail/mail_header.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Email header types as defined in RFC 8621 Section 4.1.2 *)
+(** Email header types as defined in RFC 8621 Section 4.1.2 
+
+    @canonical Jmap.Proto.Email_header *)
 
 (** {1 Raw Headers} *)
 
···
 val text_jsont : string Jsont.t
 
 (** The addresses form - list of email addresses. *)
-val addresses_jsont : Email_address.t list Jsont.t
+val addresses_jsont : Mail_address.t list Jsont.t
 
 (** The grouped addresses form - addresses with group info. *)
-val grouped_addresses_jsont : Email_address.Group.t list Jsont.t
+val grouped_addresses_jsont : Mail_address.Group.t list Jsont.t
 
 (** The message IDs form - list of message-id strings. *)
 val message_ids_jsont : string list Jsont.t

proto/mail/identity.ml lib/mail/mail_identity.ml

···
   ---------------------------------------------------------------------------*)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   name : string;
   email : string;
-  reply_to : Email_address.t list option;
-  bcc : Email_address.t list option;
+  reply_to : Mail_address.t list option;
+  bcc : Mail_address.t list option;
   text_signature : string;
   html_signature : string;
   may_delete : bool;
···
 let jsont =
   let kind = "Identity" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
   |> Jsont.Object.mem "name" Jsont.string ~dec_absent:"" ~enc:name
   |> Jsont.Object.mem "email" Jsont.string ~enc:email
-  |> Jsont.Object.opt_mem "replyTo" (Jsont.list Email_address.jsont) ~enc:reply_to
-  |> Jsont.Object.opt_mem "bcc" (Jsont.list Email_address.jsont) ~enc:bcc
+  |> Jsont.Object.opt_mem "replyTo" (Jsont.list Mail_address.jsont) ~enc:reply_to
+  |> Jsont.Object.opt_mem "bcc" (Jsont.list Mail_address.jsont) ~enc:bcc
   |> Jsont.Object.mem "textSignature" Jsont.string ~dec_absent:"" ~enc:text_signature
   |> Jsont.Object.mem "htmlSignature" Jsont.string ~dec_absent:"" ~enc:html_signature
   |> Jsont.Object.mem "mayDelete" Jsont.bool ~enc:may_delete

proto/mail/identity.mli lib/mail/mail_identity.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Identity type as defined in RFC 8621 Section 6 *)
+(** Identity type as defined in RFC 8621 Section 6 
+
+    @canonical Jmap.Proto.Identity *)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   (** Server-assigned identity id. *)
   name : string;
   (** Display name for sent emails. *)
   email : string;
   (** The email address to use. *)
-  reply_to : Email_address.t list option;
+  reply_to : Mail_address.t list option;
   (** Default Reply-To addresses. *)
-  bcc : Email_address.t list option;
+  bcc : Mail_address.t list option;
   (** Default BCC addresses. *)
   text_signature : string;
   (** Plain text signature. *)
···
   (** Whether the user may delete this identity. *)
 }
 
-val id : t -> Jmap_proto.Id.t
+val id : t -> Proto_id.t
 val name : t -> string
 val email : t -> string
-val reply_to : t -> Email_address.t list option
-val bcc : t -> Email_address.t list option
+val reply_to : t -> Mail_address.t list option
+val bcc : t -> Mail_address.t list option
 val text_signature : t -> string
 val html_signature : t -> string
 val may_delete : t -> bool

proto/mail/jmap_mail.ml

···
-(*---------------------------------------------------------------------------
-   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
-   SPDX-License-Identifier: ISC
-  ---------------------------------------------------------------------------*)
-
-(** JMAP Mail Types (RFC 8621)
-
-    This module re-exports all JMAP mail protocol types. *)
-
-module Email_address = Email_address
-module Email_header = Email_header
-module Email_body = Email_body
-module Mailbox = Mailbox
-module Thread = Thread
-module Email = Email
-module Search_snippet = Search_snippet
-module Identity = Identity
-module Submission = Submission
-module Vacation = Vacation
-module Mail_filter = Mail_filter

proto/mail/mail_filter.ml

···
-(*---------------------------------------------------------------------------
-   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
-   SPDX-License-Identifier: ISC
-  ---------------------------------------------------------------------------*)
-
-type email_filter = Email.Filter_condition.t Jmap_proto.Filter.filter
-
-let email_filter_jsont = Jmap_proto.Filter.filter_jsont Email.Filter_condition.jsont
-
-type mailbox_filter = Mailbox.Filter_condition.t Jmap_proto.Filter.filter
-
-let mailbox_filter_jsont = Jmap_proto.Filter.filter_jsont Mailbox.Filter_condition.jsont
-
-type submission_filter = Submission.Filter_condition.t Jmap_proto.Filter.filter
-
-let submission_filter_jsont = Jmap_proto.Filter.filter_jsont Submission.Filter_condition.jsont

proto/mail/mail_filter.mli lib/mail/mail_filter.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Mail-specific filter types *)
+(** Mail-specific filter types 
+
+    @canonical Jmap.Proto.Mail_filter *)
 
 (** Email filter with Email-specific conditions. *)
-type email_filter = Email.Filter_condition.t Jmap_proto.Filter.filter
+type email_filter = Mail_email.Filter_condition.t Proto_filter.filter
 
 val email_filter_jsont : email_filter Jsont.t
 
 (** Mailbox filter with Mailbox-specific conditions. *)
-type mailbox_filter = Mailbox.Filter_condition.t Jmap_proto.Filter.filter
+type mailbox_filter = Mail_mailbox.Filter_condition.t Proto_filter.filter
 
 val mailbox_filter_jsont : mailbox_filter Jsont.t
 
 (** EmailSubmission filter with Submission-specific conditions. *)
-type submission_filter = Submission.Filter_condition.t Jmap_proto.Filter.filter
+type submission_filter = Mail_submission.Filter_condition.t Proto_filter.filter
 
 val submission_filter_jsont : submission_filter Jsont.t

proto/mail/mailbox.ml lib/mail/mail_mailbox.ml

···
     Jsont.string
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   name : string;
-  parent_id : Jmap_proto.Id.t option;
+  parent_id : Proto_id.t option;
   role : role option;
   sort_order : int64;
   total_emails : int64;
···
 let jsont =
   let kind = "Mailbox" in
   (* parentId and role can be null - RFC 8621 Section 2 *)
-  let nullable_id = Jsont.(option Jmap_proto.Id.jsont) in
+  let nullable_id = Jsont.(option Proto_id.jsont) in
   let nullable_role = Jsont.(option role_jsont) in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
   |> Jsont.Object.mem "name" Jsont.string ~enc:name
   |> Jsont.Object.mem "parentId" nullable_id
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:parent_id
   |> Jsont.Object.mem "role" nullable_role
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:role
-  |> Jsont.Object.mem "sortOrder" Jmap_proto.Int53.Unsigned.jsont ~dec_absent:0L ~enc:sort_order
-  |> Jsont.Object.mem "totalEmails" Jmap_proto.Int53.Unsigned.jsont ~enc:total_emails
-  |> Jsont.Object.mem "unreadEmails" Jmap_proto.Int53.Unsigned.jsont ~enc:unread_emails
-  |> Jsont.Object.mem "totalThreads" Jmap_proto.Int53.Unsigned.jsont ~enc:total_threads
-  |> Jsont.Object.mem "unreadThreads" Jmap_proto.Int53.Unsigned.jsont ~enc:unread_threads
+  |> Jsont.Object.mem "sortOrder" Proto_int53.Unsigned.jsont ~dec_absent:0L ~enc:sort_order
+  |> Jsont.Object.mem "totalEmails" Proto_int53.Unsigned.jsont ~enc:total_emails
+  |> Jsont.Object.mem "unreadEmails" Proto_int53.Unsigned.jsont ~enc:unread_emails
+  |> Jsont.Object.mem "totalThreads" Proto_int53.Unsigned.jsont ~enc:total_threads
+  |> Jsont.Object.mem "unreadThreads" Proto_int53.Unsigned.jsont ~enc:unread_threads
   |> Jsont.Object.mem "myRights" Rights.jsont ~enc:my_rights
   |> Jsont.Object.mem "isSubscribed" Jsont.bool ~enc:is_subscribed
   |> Jsont.Object.finish
 
 module Filter_condition = struct
   type t = {
-    parent_id : Jmap_proto.Id.t option option;
+    parent_id : Proto_id.t option option;
     name : string option;
     role : role option option;
     has_any_role : bool option;
···
        - None = field absent (don't filter)
        - Some None = field present with null (filter for no parent/role)
        - Some (Some x) = field present with value (filter for specific value) *)
-    let nullable_id = Jsont.(option Jmap_proto.Id.jsont) in
+    let nullable_id = Jsont.(option Proto_id.jsont) in
     let nullable_role = Jsont.(option role_jsont) in
     Jsont.Object.map ~kind make
     |> Jsont.Object.opt_mem "parentId" nullable_id ~enc:(fun f -> f.parent_id)

proto/mail/mailbox.mli lib/mail/mail_mailbox.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Mailbox type as defined in RFC 8621 Section 2 *)
+(** Mailbox type as defined in RFC 8621 Section 2 
+
+    @canonical Jmap.Proto.Mailbox *)
 
 (** {1 Mailbox Rights} *)
 
···
 (** {1 Mailbox} *)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   (** Server-assigned mailbox id. *)
   name : string;
   (** User-visible name (UTF-8). *)
-  parent_id : Jmap_proto.Id.t option;
+  parent_id : Proto_id.t option;
   (** Id of parent mailbox, or [None] for root. *)
   role : role option;
   (** Standard role, if any. *)
···
   (** Whether user is subscribed to this mailbox. *)
 }
 
-val id : t -> Jmap_proto.Id.t
+val id : t -> Proto_id.t
 val name : t -> string
-val parent_id : t -> Jmap_proto.Id.t option
+val parent_id : t -> Proto_id.t option
 val role : t -> role option
 val sort_order : t -> int64
 val total_emails : t -> int64
···
 (** Filter conditions for Mailbox/query. *)
 module Filter_condition : sig
   type t = {
-    parent_id : Jmap_proto.Id.t option option;
+    parent_id : Proto_id.t option option;
     (** Filter by parent. [Some None] = top-level only. *)
     name : string option;
     (** Filter by exact name match. *)

proto/mail/search_snippet.ml lib/mail/mail_snippet.ml

···
   ---------------------------------------------------------------------------*)
 
 type t = {
-  email_id : Jmap_proto.Id.t;
+  email_id : Proto_id.t;
   subject : string option;
   preview : string option;
 }
···
   (* subject and preview can be null per RFC 8621 Section 5 *)
   let nullable_string = Jsont.(option string) in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "emailId" Jmap_proto.Id.jsont ~enc:email_id
+  |> Jsont.Object.mem "emailId" Proto_id.jsont ~enc:email_id
   |> Jsont.Object.mem "subject" nullable_string
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:subject
   |> Jsont.Object.mem "preview" nullable_string

proto/mail/search_snippet.mli lib/mail/mail_snippet.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** SearchSnippet type as defined in RFC 8621 Section 5 *)
+(** SearchSnippet type as defined in RFC 8621 Section 5 
+
+    @canonical Jmap.Proto.Search_snippet *)
 
 type t = {
-  email_id : Jmap_proto.Id.t;
+  email_id : Proto_id.t;
   (** The email this snippet is for. *)
   subject : string option;
   (** HTML snippet of matching subject text. *)
···
   (** HTML snippet of matching body text. *)
 }
 
-val email_id : t -> Jmap_proto.Id.t
+val email_id : t -> Proto_id.t
 val subject : t -> string option
 val preview : t -> string option
 

proto/mail/submission.ml lib/mail/mail_submission.ml

···
     let kind = "EmailSubmission Address" in
     Jsont.Object.map ~kind make
     |> Jsont.Object.mem "email" Jsont.string ~enc:email
-    |> Jsont.Object.opt_mem "parameters" (Jmap_proto.Json_map.of_string Jsont.string) ~enc:parameters
+    |> Jsont.Object.opt_mem "parameters" (Proto_json_map.of_string Jsont.string) ~enc:parameters
     |> Jsont.Object.finish
 end
 
···
     ~dec:undo_status_of_string ~enc:undo_status_to_string Jsont.string
 
 type t = {
-  id : Jmap_proto.Id.t;
-  identity_id : Jmap_proto.Id.t;
-  email_id : Jmap_proto.Id.t;
-  thread_id : Jmap_proto.Id.t;
+  id : Proto_id.t;
+  identity_id : Proto_id.t;
+  email_id : Proto_id.t;
+  thread_id : Proto_id.t;
   envelope : Envelope.t option;
   send_at : Ptime.t;
   undo_status : undo_status;
   delivery_status : (string * Delivery_status.t) list option;
-  dsn_blob_ids : Jmap_proto.Id.t list;
-  mdn_blob_ids : Jmap_proto.Id.t list;
+  dsn_blob_ids : Proto_id.t list;
+  mdn_blob_ids : Proto_id.t list;
 }
 
 let id t = t.id
···
 let jsont =
   let kind = "EmailSubmission" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
-  |> Jsont.Object.mem "identityId" Jmap_proto.Id.jsont ~enc:identity_id
-  |> Jsont.Object.mem "emailId" Jmap_proto.Id.jsont ~enc:email_id
-  |> Jsont.Object.mem "threadId" Jmap_proto.Id.jsont ~enc:thread_id
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
+  |> Jsont.Object.mem "identityId" Proto_id.jsont ~enc:identity_id
+  |> Jsont.Object.mem "emailId" Proto_id.jsont ~enc:email_id
+  |> Jsont.Object.mem "threadId" Proto_id.jsont ~enc:thread_id
   |> Jsont.Object.opt_mem "envelope" Envelope.jsont ~enc:envelope
-  |> Jsont.Object.mem "sendAt" Jmap_proto.Date.Utc.jsont ~enc:send_at
+  |> Jsont.Object.mem "sendAt" Proto_date.Utc.jsont ~enc:send_at
   |> Jsont.Object.mem "undoStatus" undo_status_jsont ~enc:undo_status
-  |> Jsont.Object.opt_mem "deliveryStatus" (Jmap_proto.Json_map.of_string Delivery_status.jsont) ~enc:delivery_status
-  |> Jsont.Object.mem "dsnBlobIds" (Jsont.list Jmap_proto.Id.jsont) ~dec_absent:[] ~enc:dsn_blob_ids
-  |> Jsont.Object.mem "mdnBlobIds" (Jsont.list Jmap_proto.Id.jsont) ~dec_absent:[] ~enc:mdn_blob_ids
+  |> Jsont.Object.opt_mem "deliveryStatus" (Proto_json_map.of_string Delivery_status.jsont) ~enc:delivery_status
+  |> Jsont.Object.mem "dsnBlobIds" (Jsont.list Proto_id.jsont) ~dec_absent:[] ~enc:dsn_blob_ids
+  |> Jsont.Object.mem "mdnBlobIds" (Jsont.list Proto_id.jsont) ~dec_absent:[] ~enc:mdn_blob_ids
   |> Jsont.Object.finish
 
 module Filter_condition = struct
   type t = {
-    identity_ids : Jmap_proto.Id.t list option;
-    email_ids : Jmap_proto.Id.t list option;
-    thread_ids : Jmap_proto.Id.t list option;
+    identity_ids : Proto_id.t list option;
+    email_ids : Proto_id.t list option;
+    thread_ids : Proto_id.t list option;
     undo_status : undo_status option;
     before : Ptime.t option;
     after : Ptime.t option;
···
   let jsont =
     let kind = "EmailSubmissionFilterCondition" in
     Jsont.Object.map ~kind make
-    |> Jsont.Object.opt_mem "identityIds" (Jsont.list Jmap_proto.Id.jsont) ~enc:(fun f -> f.identity_ids)
-    |> Jsont.Object.opt_mem "emailIds" (Jsont.list Jmap_proto.Id.jsont) ~enc:(fun f -> f.email_ids)
-    |> Jsont.Object.opt_mem "threadIds" (Jsont.list Jmap_proto.Id.jsont) ~enc:(fun f -> f.thread_ids)
+    |> Jsont.Object.opt_mem "identityIds" (Jsont.list Proto_id.jsont) ~enc:(fun f -> f.identity_ids)
+    |> Jsont.Object.opt_mem "emailIds" (Jsont.list Proto_id.jsont) ~enc:(fun f -> f.email_ids)
+    |> Jsont.Object.opt_mem "threadIds" (Jsont.list Proto_id.jsont) ~enc:(fun f -> f.thread_ids)
     |> Jsont.Object.opt_mem "undoStatus" undo_status_jsont ~enc:(fun f -> f.undo_status)
-    |> Jsont.Object.opt_mem "before" Jmap_proto.Date.Utc.jsont ~enc:(fun f -> f.before)
-    |> Jsont.Object.opt_mem "after" Jmap_proto.Date.Utc.jsont ~enc:(fun f -> f.after)
+    |> Jsont.Object.opt_mem "before" Proto_date.Utc.jsont ~enc:(fun f -> f.before)
+    |> Jsont.Object.opt_mem "after" Proto_date.Utc.jsont ~enc:(fun f -> f.after)
     |> Jsont.Object.finish
 end

proto/mail/submission.mli lib/mail/mail_submission.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** EmailSubmission type as defined in RFC 8621 Section 7 *)
+(** EmailSubmission type as defined in RFC 8621 Section 7 
+
+    @canonical Jmap.Proto.Submission *)
 
 (** {1 Address} *)
 
···
 (** {1 EmailSubmission} *)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   (** Server-assigned submission id. *)
-  identity_id : Jmap_proto.Id.t;
+  identity_id : Proto_id.t;
   (** The identity used to send. *)
-  email_id : Jmap_proto.Id.t;
+  email_id : Proto_id.t;
   (** The email that was submitted. *)
-  thread_id : Jmap_proto.Id.t;
+  thread_id : Proto_id.t;
   (** The thread of the submitted email. *)
   envelope : Envelope.t option;
   (** The envelope used, if different from email headers. *)
···
   (** Whether sending can be undone. *)
   delivery_status : (string * Delivery_status.t) list option;
   (** Delivery status per recipient. *)
-  dsn_blob_ids : Jmap_proto.Id.t list;
+  dsn_blob_ids : Proto_id.t list;
   (** Blob ids of received DSN messages. *)
-  mdn_blob_ids : Jmap_proto.Id.t list;
+  mdn_blob_ids : Proto_id.t list;
   (** Blob ids of received MDN messages. *)
 }
 
-val id : t -> Jmap_proto.Id.t
-val identity_id : t -> Jmap_proto.Id.t
-val email_id : t -> Jmap_proto.Id.t
-val thread_id : t -> Jmap_proto.Id.t
+val id : t -> Proto_id.t
+val identity_id : t -> Proto_id.t
+val email_id : t -> Proto_id.t
+val thread_id : t -> Proto_id.t
 val envelope : t -> Envelope.t option
 val send_at : t -> Ptime.t
 val undo_status : t -> undo_status
 val delivery_status : t -> (string * Delivery_status.t) list option
-val dsn_blob_ids : t -> Jmap_proto.Id.t list
-val mdn_blob_ids : t -> Jmap_proto.Id.t list
+val dsn_blob_ids : t -> Proto_id.t list
+val mdn_blob_ids : t -> Proto_id.t list
 
 val jsont : t Jsont.t
 
···
 
 module Filter_condition : sig
   type t = {
-    identity_ids : Jmap_proto.Id.t list option;
-    email_ids : Jmap_proto.Id.t list option;
-    thread_ids : Jmap_proto.Id.t list option;
+    identity_ids : Proto_id.t list option;
+    email_ids : Proto_id.t list option;
+    thread_ids : Proto_id.t list option;
     undo_status : undo_status option;
     before : Ptime.t option;
     after : Ptime.t option;

proto/mail/thread.ml lib/mail/mail_thread.ml

···
   ---------------------------------------------------------------------------*)
 
 type t = {
-  id : Jmap_proto.Id.t;
-  email_ids : Jmap_proto.Id.t list;
+  id : Proto_id.t;
+  email_ids : Proto_id.t list;
 }
 
 let id t = t.id
···
 let jsont =
   let kind = "Thread" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
-  |> Jsont.Object.mem "emailIds" (Jsont.list Jmap_proto.Id.jsont) ~enc:email_ids
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
+  |> Jsont.Object.mem "emailIds" (Jsont.list Proto_id.jsont) ~enc:email_ids
   |> Jsont.Object.finish

proto/mail/thread.mli lib/mail/mail_thread.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** Thread type as defined in RFC 8621 Section 3 *)
+(** Thread type as defined in RFC 8621 Section 3 
+
+    @canonical Jmap.Proto.Thread *)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   (** Server-assigned thread id. *)
-  email_ids : Jmap_proto.Id.t list;
+  email_ids : Proto_id.t list;
   (** Ids of emails in this thread, in date order. *)
 }
 
-val id : t -> Jmap_proto.Id.t
-val email_ids : t -> Jmap_proto.Id.t list
+val id : t -> Proto_id.t
+val email_ids : t -> Proto_id.t list
 
 val jsont : t Jsont.t

proto/mail/vacation.ml lib/mail/mail_vacation.ml

···
   ---------------------------------------------------------------------------*)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   is_enabled : bool;
   from_date : Ptime.t option;
   to_date : Ptime.t option;
···
 let text_body t = t.text_body
 let html_body t = t.html_body
 
-let singleton_id = Jmap_proto.Id.of_string_exn "singleton"
+let singleton_id = Proto_id.of_string_exn "singleton"
 
 let make id is_enabled from_date to_date subject text_body html_body =
   { id; is_enabled; from_date; to_date; subject; text_body; html_body }
···
   (* subject, textBody, htmlBody can be null per RFC 8621 Section 8 *)
   let nullable_string = Jsont.(option string) in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Jmap_proto.Id.jsont ~enc:id
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
   |> Jsont.Object.mem "isEnabled" Jsont.bool ~enc:is_enabled
-  |> Jsont.Object.opt_mem "fromDate" Jmap_proto.Date.Utc.jsont ~enc:from_date
-  |> Jsont.Object.opt_mem "toDate" Jmap_proto.Date.Utc.jsont ~enc:to_date
+  |> Jsont.Object.opt_mem "fromDate" Proto_date.Utc.jsont ~enc:from_date
+  |> Jsont.Object.opt_mem "toDate" Proto_date.Utc.jsont ~enc:to_date
   |> Jsont.Object.mem "subject" nullable_string
        ~dec_absent:None ~enc_omit:Option.is_none ~enc:subject
   |> Jsont.Object.mem "textBody" nullable_string

proto/mail/vacation.mli lib/mail/mail_vacation.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** VacationResponse type as defined in RFC 8621 Section 8 *)
+(** VacationResponse type as defined in RFC 8621 Section 8 
+
+    @canonical Jmap.Proto.Vacation *)
 
 type t = {
-  id : Jmap_proto.Id.t;
+  id : Proto_id.t;
   (** Always "singleton" - there is only one vacation response. *)
   is_enabled : bool;
   (** Whether the vacation response is active. *)
···
   (** HTML body. *)
 }
 
-val id : t -> Jmap_proto.Id.t
+val id : t -> Proto_id.t
 val is_enabled : t -> bool
 val from_date : t -> Ptime.t option
 val to_date : t -> Ptime.t option
···
 val jsont : t Jsont.t
 
 (** The singleton id for VacationResponse. *)
-val singleton_id : Jmap_proto.Id.t
+val singleton_id : Proto_id.t

proto/method_.ml

···
-(*---------------------------------------------------------------------------
-   Copyright (c) 2025 Anil Madhavapeddy. All rights reserved.
-   SPDX-License-Identifier: ISC
-  ---------------------------------------------------------------------------*)
-
-(* Foo/get *)
-
-type get_args = {
-  account_id : Id.t;
-  ids : Id.t list option;
-  properties : string list option;
-}
-
-let get_args ~account_id ?ids ?properties () =
-  { account_id; ids; properties }
-
-let get_args_make account_id ids properties =
-  { account_id; ids; properties }
-
-let get_args_jsont =
-  let kind = "GetArgs" in
-  Jsont.Object.map ~kind get_args_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.opt_mem "ids" (Jsont.list Id.jsont) ~enc:(fun a -> a.ids)
-  |> Jsont.Object.opt_mem "properties" (Jsont.list Jsont.string) ~enc:(fun a -> a.properties)
-  |> Jsont.Object.finish
-
-type 'a get_response = {
-  account_id : Id.t;
-  state : string;
-  list : 'a list;
-  not_found : Id.t list;
-}
-
-let get_response_jsont (type a) (obj_jsont : a Jsont.t) : a get_response Jsont.t =
-  let kind = "GetResponse" in
-  let make account_id state list not_found =
-    { account_id; state; list; not_found }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.mem "state" Jsont.string ~enc:(fun r -> r.state)
-  |> Jsont.Object.mem "list" (Jsont.list obj_jsont) ~enc:(fun r -> r.list)
-  |> Jsont.Object.mem "notFound" (Jsont.list Id.jsont) ~enc:(fun r -> r.not_found)
-  |> Jsont.Object.finish
-
-(* Foo/changes *)
-
-type changes_args = {
-  account_id : Id.t;
-  since_state : string;
-  max_changes : int64 option;
-}
-
-let changes_args ~account_id ~since_state ?max_changes () =
-  { account_id; since_state; max_changes }
-
-let changes_args_make account_id since_state max_changes =
-  { account_id; since_state; max_changes }
-
-let changes_args_jsont =
-  let kind = "ChangesArgs" in
-  Jsont.Object.map ~kind changes_args_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.mem "sinceState" Jsont.string ~enc:(fun a -> a.since_state)
-  |> Jsont.Object.opt_mem "maxChanges" Int53.Unsigned.jsont ~enc:(fun a -> a.max_changes)
-  |> Jsont.Object.finish
-
-type changes_response = {
-  account_id : Id.t;
-  old_state : string;
-  new_state : string;
-  has_more_changes : bool;
-  created : Id.t list;
-  updated : Id.t list;
-  destroyed : Id.t list;
-}
-
-let changes_response_make account_id old_state new_state has_more_changes
-    created updated destroyed =
-  { account_id; old_state; new_state; has_more_changes; created; updated; destroyed }
-
-let changes_response_jsont =
-  let kind = "ChangesResponse" in
-  Jsont.Object.map ~kind changes_response_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
-  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
-  |> Jsont.Object.mem "hasMoreChanges" Jsont.bool ~enc:(fun r -> r.has_more_changes)
-  |> Jsont.Object.mem "created" (Jsont.list Id.jsont) ~enc:(fun r -> r.created)
-  |> Jsont.Object.mem "updated" (Jsont.list Id.jsont) ~enc:(fun r -> r.updated)
-  |> Jsont.Object.mem "destroyed" (Jsont.list Id.jsont) ~enc:(fun r -> r.destroyed)
-  |> Jsont.Object.finish
-
-(* Foo/set *)
-
-type 'a set_args = {
-  account_id : Id.t;
-  if_in_state : string option;
-  create : (Id.t * 'a) list option;
-  update : (Id.t * Jsont.json) list option;
-  destroy : Id.t list option;
-}
-
-let set_args ~account_id ?if_in_state ?create ?update ?destroy () =
-  { account_id; if_in_state; create; update; destroy }
-
-let set_args_jsont (type a) (obj_jsont : a Jsont.t) : a set_args Jsont.t =
-  let kind = "SetArgs" in
-  let make account_id if_in_state create update destroy =
-    { account_id; if_in_state; create; update; destroy }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.opt_mem "ifInState" Jsont.string ~enc:(fun a -> a.if_in_state)
-  |> Jsont.Object.opt_mem "create" (Json_map.of_id obj_jsont) ~enc:(fun a -> a.create)
-  |> Jsont.Object.opt_mem "update" (Json_map.of_id Jsont.json) ~enc:(fun a -> a.update)
-  |> Jsont.Object.opt_mem "destroy" (Jsont.list Id.jsont) ~enc:(fun a -> a.destroy)
-  |> Jsont.Object.finish
-
-type 'a set_response = {
-  account_id : Id.t;
-  old_state : string option;
-  new_state : string;
-  created : (Id.t * 'a) list option;
-  updated : (Id.t * 'a option) list option;
-  destroyed : Id.t list option;
-  not_created : (Id.t * Error.set_error) list option;
-  not_updated : (Id.t * Error.set_error) list option;
-  not_destroyed : (Id.t * Error.set_error) list option;
-}
-
-let set_response_jsont (type a) (obj_jsont : a Jsont.t) : a set_response Jsont.t =
-  let kind = "SetResponse" in
-  let make account_id old_state new_state created updated destroyed
-      not_created not_updated not_destroyed =
-    { account_id; old_state; new_state; created; updated; destroyed;
-      not_created; not_updated; not_destroyed }
-  in
-  (* For updated values, the server may return null or an object - RFC 8620 Section 5.3 *)
-  (* "Id[Foo|null]" means map values can be null, use Jsont.option to handle this *)
-  let nullable_obj = Jsont.(option obj_jsont) in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.opt_mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
-  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
-  |> Jsont.Object.opt_mem "created" (Json_map.of_id obj_jsont) ~enc:(fun r -> r.created)
-  |> Jsont.Object.opt_mem "updated" (Json_map.of_id nullable_obj) ~enc:(fun r -> r.updated)
-  |> Jsont.Object.opt_mem "destroyed" (Jsont.list Id.jsont) ~enc:(fun r -> r.destroyed)
-  |> Jsont.Object.opt_mem "notCreated" (Json_map.of_id Error.set_error_jsont) ~enc:(fun r -> r.not_created)
-  |> Jsont.Object.opt_mem "notUpdated" (Json_map.of_id Error.set_error_jsont) ~enc:(fun r -> r.not_updated)
-  |> Jsont.Object.opt_mem "notDestroyed" (Json_map.of_id Error.set_error_jsont) ~enc:(fun r -> r.not_destroyed)
-  |> Jsont.Object.finish
-
-(* Foo/copy *)
-
-type 'a copy_args = {
-  from_account_id : Id.t;
-  if_from_in_state : string option;
-  account_id : Id.t;
-  if_in_state : string option;
-  create : (Id.t * 'a) list;
-  on_success_destroy_original : bool;
-  destroy_from_if_in_state : string option;
-}
-
-let copy_args_jsont (type a) (obj_jsont : a Jsont.t) : a copy_args Jsont.t =
-  let kind = "CopyArgs" in
-  let make from_account_id if_from_in_state account_id if_in_state create
-      on_success_destroy_original destroy_from_if_in_state =
-    { from_account_id; if_from_in_state; account_id; if_in_state; create;
-      on_success_destroy_original; destroy_from_if_in_state }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "fromAccountId" Id.jsont ~enc:(fun a -> a.from_account_id)
-  |> Jsont.Object.opt_mem "ifFromInState" Jsont.string ~enc:(fun a -> a.if_from_in_state)
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.opt_mem "ifInState" Jsont.string ~enc:(fun a -> a.if_in_state)
-  |> Jsont.Object.mem "create" (Json_map.of_id obj_jsont) ~enc:(fun a -> a.create)
-  |> Jsont.Object.mem "onSuccessDestroyOriginal" Jsont.bool ~dec_absent:false
-       ~enc:(fun a -> a.on_success_destroy_original)
-       ~enc_omit:(fun b -> not b)
-  |> Jsont.Object.opt_mem "destroyFromIfInState" Jsont.string ~enc:(fun a -> a.destroy_from_if_in_state)
-  |> Jsont.Object.finish
-
-type 'a copy_response = {
-  from_account_id : Id.t;
-  account_id : Id.t;
-  old_state : string option;
-  new_state : string;
-  created : (Id.t * 'a) list option;
-  not_created : (Id.t * Error.set_error) list option;
-}
-
-let copy_response_jsont (type a) (obj_jsont : a Jsont.t) : a copy_response Jsont.t =
-  let kind = "CopyResponse" in
-  let make from_account_id account_id old_state new_state created not_created =
-    { from_account_id; account_id; old_state; new_state; created; not_created }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "fromAccountId" Id.jsont ~enc:(fun r -> r.from_account_id)
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.opt_mem "oldState" Jsont.string ~enc:(fun r -> r.old_state)
-  |> Jsont.Object.mem "newState" Jsont.string ~enc:(fun r -> r.new_state)
-  |> Jsont.Object.opt_mem "created" (Json_map.of_id obj_jsont) ~enc:(fun r -> r.created)
-  |> Jsont.Object.opt_mem "notCreated" (Json_map.of_id Error.set_error_jsont) ~enc:(fun r -> r.not_created)
-  |> Jsont.Object.finish
-
-(* Foo/query *)
-
-type 'filter query_args = {
-  account_id : Id.t;
-  filter : 'filter Filter.filter option;
-  sort : Filter.comparator list option;
-  position : int64;
-  anchor : Id.t option;
-  anchor_offset : int64;
-  limit : int64 option;
-  calculate_total : bool;
-}
-
-let query_args ~account_id ?filter ?sort ?(position = 0L) ?anchor
-    ?(anchor_offset = 0L) ?limit ?(calculate_total = false) () =
-  { account_id; filter; sort; position; anchor; anchor_offset; limit; calculate_total }
-
-let query_args_jsont (type f) (filter_cond_jsont : f Jsont.t) : f query_args Jsont.t =
-  let kind = "QueryArgs" in
-  let make account_id filter sort position anchor anchor_offset limit calculate_total =
-    { account_id; filter; sort; position; anchor; anchor_offset; limit; calculate_total }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.opt_mem "filter" (Filter.filter_jsont filter_cond_jsont) ~enc:(fun a -> a.filter)
-  |> Jsont.Object.opt_mem "sort" (Jsont.list Filter.comparator_jsont) ~enc:(fun a -> a.sort)
-  |> Jsont.Object.mem "position" Int53.Signed.jsont ~dec_absent:0L ~enc:(fun a -> a.position)
-       ~enc_omit:(fun p -> p = 0L)
-  |> Jsont.Object.opt_mem "anchor" Id.jsont ~enc:(fun a -> a.anchor)
-  |> Jsont.Object.mem "anchorOffset" Int53.Signed.jsont ~dec_absent:0L ~enc:(fun a -> a.anchor_offset)
-       ~enc_omit:(fun o -> o = 0L)
-  |> Jsont.Object.opt_mem "limit" Int53.Unsigned.jsont ~enc:(fun a -> a.limit)
-  |> Jsont.Object.mem "calculateTotal" Jsont.bool ~dec_absent:false ~enc:(fun a -> a.calculate_total)
-       ~enc_omit:(fun b -> not b)
-  |> Jsont.Object.finish
-
-type query_response = {
-  account_id : Id.t;
-  query_state : string;
-  can_calculate_changes : bool;
-  position : int64;
-  ids : Id.t list;
-  total : int64 option;
-}
-
-let query_response_make account_id query_state can_calculate_changes position ids total =
-  { account_id; query_state; can_calculate_changes; position; ids; total }
-
-let query_response_jsont =
-  let kind = "QueryResponse" in
-  Jsont.Object.map ~kind query_response_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.mem "queryState" Jsont.string ~enc:(fun r -> r.query_state)
-  |> Jsont.Object.mem "canCalculateChanges" Jsont.bool ~enc:(fun r -> r.can_calculate_changes)
-  |> Jsont.Object.mem "position" Int53.Unsigned.jsont ~enc:(fun r -> r.position)
-  |> Jsont.Object.mem "ids" (Jsont.list Id.jsont) ~enc:(fun r -> r.ids)
-  |> Jsont.Object.opt_mem "total" Int53.Unsigned.jsont ~enc:(fun r -> r.total)
-  |> Jsont.Object.finish
-
-(* Foo/queryChanges *)
-
-type 'filter query_changes_args = {
-  account_id : Id.t;
-  filter : 'filter Filter.filter option;
-  sort : Filter.comparator list option;
-  since_query_state : string;
-  max_changes : int64 option;
-  up_to_id : Id.t option;
-  calculate_total : bool;
-}
-
-let query_changes_args_jsont (type f) (filter_cond_jsont : f Jsont.t) : f query_changes_args Jsont.t =
-  let kind = "QueryChangesArgs" in
-  let make account_id filter sort since_query_state max_changes up_to_id calculate_total =
-    { account_id; filter; sort; since_query_state; max_changes; up_to_id; calculate_total }
-  in
-  Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
-  |> Jsont.Object.opt_mem "filter" (Filter.filter_jsont filter_cond_jsont) ~enc:(fun a -> a.filter)
-  |> Jsont.Object.opt_mem "sort" (Jsont.list Filter.comparator_jsont) ~enc:(fun a -> a.sort)
-  |> Jsont.Object.mem "sinceQueryState" Jsont.string ~enc:(fun a -> a.since_query_state)
-  |> Jsont.Object.opt_mem "maxChanges" Int53.Unsigned.jsont ~enc:(fun a -> a.max_changes)
-  |> Jsont.Object.opt_mem "upToId" Id.jsont ~enc:(fun a -> a.up_to_id)
-  |> Jsont.Object.mem "calculateTotal" Jsont.bool ~dec_absent:false ~enc:(fun a -> a.calculate_total)
-       ~enc_omit:(fun b -> not b)
-  |> Jsont.Object.finish
-
-type query_changes_response = {
-  account_id : Id.t;
-  old_query_state : string;
-  new_query_state : string;
-  total : int64 option;
-  removed : Id.t list;
-  added : Filter.added_item list;
-}
-
-let query_changes_response_make account_id old_query_state new_query_state total removed added =
-  { account_id; old_query_state; new_query_state; total; removed; added }
-
-let query_changes_response_jsont =
-  let kind = "QueryChangesResponse" in
-  Jsont.Object.map ~kind query_changes_response_make
-  |> Jsont.Object.mem "accountId" Id.jsont ~enc:(fun r -> r.account_id)
-  |> Jsont.Object.mem "oldQueryState" Jsont.string ~enc:(fun r -> r.old_query_state)
-  |> Jsont.Object.mem "newQueryState" Jsont.string ~enc:(fun r -> r.new_query_state)
-  |> Jsont.Object.opt_mem "total" Int53.Unsigned.jsont ~enc:(fun r -> r.total)
-  |> Jsont.Object.mem "removed" (Jsont.list Id.jsont) ~enc:(fun r -> r.removed)
-  |> Jsont.Object.mem "added" (Jsont.list Filter.added_item_jsont) ~enc:(fun r -> r.added)
-  |> Jsont.Object.finish

proto/method_.mli lib/proto/proto_method.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP standard method types as defined in RFC 8620 Section 5 *)
+(** JMAP standard method types as defined in RFC 8620 Section 5 
+
+    @canonical Jmap.Proto.Method *)
 
 (** {1 Foo/get} *)
 
 (** Arguments for /get methods. *)
 type get_args = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   (** The account to fetch from. *)
-  ids : Id.t list option;
+  ids : Proto_id.t list option;
   (** The ids to fetch. [None] means fetch all. *)
   properties : string list option;
   (** Properties to include. [None] means all. *)
 }
 
 val get_args :
-  account_id:Id.t ->
-  ?ids:Id.t list ->
+  account_id:Proto_id.t ->
+  ?ids:Proto_id.t list ->
   ?properties:string list ->
   unit ->
   get_args
···
 
 (** Response for /get methods. *)
 type 'a get_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   (** The account fetched from. *)
   state : string;
   (** Current state string. *)
   list : 'a list;
   (** The objects fetched. *)
-  not_found : Id.t list;
+  not_found : Proto_id.t list;
   (** Ids that were not found. *)
 }
 
···
 
 (** Arguments for /changes methods. *)
 type changes_args = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   since_state : string;
   max_changes : int64 option;
 }
 
 val changes_args :
-  account_id:Id.t ->
+  account_id:Proto_id.t ->
   since_state:string ->
   ?max_changes:int64 ->
   unit ->
···
 
 (** Response for /changes methods. *)
 type changes_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   old_state : string;
   new_state : string;
   has_more_changes : bool;
-  created : Id.t list;
-  updated : Id.t list;
-  destroyed : Id.t list;
+  created : Proto_id.t list;
+  updated : Proto_id.t list;
+  destroyed : Proto_id.t list;
 }
 
 val changes_response_jsont : changes_response Jsont.t
···
 
     The ['a] type parameter is the object type being created/updated. *)
 type 'a set_args = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   if_in_state : string option;
   (** If set, only apply if current state matches. *)
-  create : (Id.t * 'a) list option;
+  create : (Proto_id.t * 'a) list option;
   (** Objects to create, keyed by temporary id. *)
-  update : (Id.t * Jsont.json) list option;
+  update : (Proto_id.t * Jsont.json) list option;
   (** Objects to update. Value is a PatchObject. *)
-  destroy : Id.t list option;
+  destroy : Proto_id.t list option;
   (** Ids to destroy. *)
 }
 
 val set_args :
-  account_id:Id.t ->
+  account_id:Proto_id.t ->
   ?if_in_state:string ->
-  ?create:(Id.t * 'a) list ->
-  ?update:(Id.t * Jsont.json) list ->
-  ?destroy:Id.t list ->
+  ?create:(Proto_id.t * 'a) list ->
+  ?update:(Proto_id.t * Jsont.json) list ->
+  ?destroy:Proto_id.t list ->
   unit ->
   'a set_args
 
···
 
 (** Response for /set methods. *)
 type 'a set_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   old_state : string option;
   new_state : string;
-  created : (Id.t * 'a) list option;
+  created : (Proto_id.t * 'a) list option;
   (** Successfully created objects, keyed by temporary id. *)
-  updated : (Id.t * 'a option) list option;
+  updated : (Proto_id.t * 'a option) list option;
   (** Successfully updated objects. Value may include server-set properties. *)
-  destroyed : Id.t list option;
+  destroyed : Proto_id.t list option;
   (** Successfully destroyed ids. *)
-  not_created : (Id.t * Error.set_error) list option;
+  not_created : (Proto_id.t * Proto_error.set_error) list option;
   (** Failed creates. *)
-  not_updated : (Id.t * Error.set_error) list option;
+  not_updated : (Proto_id.t * Proto_error.set_error) list option;
   (** Failed updates. *)
-  not_destroyed : (Id.t * Error.set_error) list option;
+  not_destroyed : (Proto_id.t * Proto_error.set_error) list option;
   (** Failed destroys. *)
 }
 
···
 
 (** Arguments for /copy methods. *)
 type 'a copy_args = {
-  from_account_id : Id.t;
+  from_account_id : Proto_id.t;
   if_from_in_state : string option;
-  account_id : Id.t;
+  account_id : Proto_id.t;
   if_in_state : string option;
-  create : (Id.t * 'a) list;
+  create : (Proto_id.t * 'a) list;
   on_success_destroy_original : bool;
   destroy_from_if_in_state : string option;
 }
···
 
 (** Response for /copy methods. *)
 type 'a copy_response = {
-  from_account_id : Id.t;
-  account_id : Id.t;
+  from_account_id : Proto_id.t;
+  account_id : Proto_id.t;
   old_state : string option;
   new_state : string;
-  created : (Id.t * 'a) list option;
-  not_created : (Id.t * Error.set_error) list option;
+  created : (Proto_id.t * 'a) list option;
+  not_created : (Proto_id.t * Proto_error.set_error) list option;
 }
 
 val copy_response_jsont : 'a Jsont.t -> 'a copy_response Jsont.t
···
 
 (** Arguments for /query methods. *)
 type 'filter query_args = {
-  account_id : Id.t;
-  filter : 'filter Filter.filter option;
-  sort : Filter.comparator list option;
+  account_id : Proto_id.t;
+  filter : 'filter Proto_filter.filter option;
+  sort : Proto_filter.comparator list option;
   position : int64;
-  anchor : Id.t option;
+  anchor : Proto_id.t option;
   anchor_offset : int64;
   limit : int64 option;
   calculate_total : bool;
 }
 
 val query_args :
-  account_id:Id.t ->
-  ?filter:'filter Filter.filter ->
-  ?sort:Filter.comparator list ->
+  account_id:Proto_id.t ->
+  ?filter:'filter Proto_filter.filter ->
+  ?sort:Proto_filter.comparator list ->
   ?position:int64 ->
-  ?anchor:Id.t ->
+  ?anchor:Proto_id.t ->
   ?anchor_offset:int64 ->
   ?limit:int64 ->
   ?calculate_total:bool ->
···
 
 (** Response for /query methods. *)
 type query_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   query_state : string;
   can_calculate_changes : bool;
   position : int64;
-  ids : Id.t list;
+  ids : Proto_id.t list;
   total : int64 option;
 }
 
···
 
 (** Arguments for /queryChanges methods. *)
 type 'filter query_changes_args = {
-  account_id : Id.t;
-  filter : 'filter Filter.filter option;
-  sort : Filter.comparator list option;
+  account_id : Proto_id.t;
+  filter : 'filter Proto_filter.filter option;
+  sort : Proto_filter.comparator list option;
   since_query_state : string;
   max_changes : int64 option;
-  up_to_id : Id.t option;
+  up_to_id : Proto_id.t option;
   calculate_total : bool;
 }
 
···
 
 (** Response for /queryChanges methods. *)
 type query_changes_response = {
-  account_id : Id.t;
+  account_id : Proto_id.t;
   old_query_state : string;
   new_query_state : string;
   total : int64 option;
-  removed : Id.t list;
-  added : Filter.added_item list;
+  removed : Proto_id.t list;
+  added : Proto_filter.added_item list;
 }
 
 val query_changes_response_jsont : query_changes_response Jsont.t

proto/push.ml lib/proto/proto_push.ml

···
 
   type t = {
     type_ : string;
-    changed : (Id.t * type_state list) list;
+    changed : (Proto_id.t * type_state list) list;
   }
 
   (* The changed object is account_id -> { typeName: state } *)
   let changed_jsont =
     let kind = "Changed" in
     (* Inner is type -> state string map *)
-    let type_states_jsont = Json_map.of_string Jsont.string in
+    let type_states_jsont = Proto_json_map.of_string Jsont.string in
     (* Convert list of (string * string) to type_state list *)
     let decode_type_states pairs =
       List.map (fun (type_name, state) -> { type_name; state }) pairs
···
     let encode_type_states states =
       List.map (fun ts -> (ts.type_name, ts.state)) states
     in
-    Json_map.of_id
+    Proto_json_map.of_id
       (Jsont.map ~kind ~dec:decode_type_states ~enc:encode_type_states type_states_jsont)
 
   let make type_ changed = { type_; changed }
···
   |> Jsont.Object.finish
 
 type t = {
-  id : Id.t;
+  id : Proto_id.t;
   device_client_id : string;
   url : string;
   keys : push_keys option;
···
 let jsont =
   let kind = "PushSubscription" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "id" Id.jsont ~enc:id
+  |> Jsont.Object.mem "id" Proto_id.jsont ~enc:id
   |> Jsont.Object.mem "deviceClientId" Jsont.string ~enc:device_client_id
   |> Jsont.Object.mem "url" Jsont.string ~enc:url
   |> Jsont.Object.opt_mem "keys" push_keys_jsont ~enc:keys
   |> Jsont.Object.opt_mem "verificationCode" Jsont.string ~enc:verification_code
-  |> Jsont.Object.opt_mem "expires" Date.Utc.jsont ~enc:expires
+  |> Jsont.Object.opt_mem "expires" Proto_date.Utc.jsont ~enc:expires
   |> Jsont.Object.opt_mem "types" (Jsont.list Jsont.string) ~enc:types
   |> Jsont.Object.finish
 
-let get_args_jsont = Method_.get_args_jsont
-let get_response_jsont = Method_.get_response_jsont jsont
+let get_args_jsont = Proto_method.get_args_jsont
+let get_response_jsont = Proto_method.get_response_jsont jsont
 
 type create_args = {
   device_client_id : string;
···
   |> Jsont.Object.finish
 
 type set_args = {
-  account_id : Id.t option;
+  account_id : Proto_id.t option;
   if_in_state : string option;
-  create : (Id.t * create_args) list option;
-  update : (Id.t * Jsont.json) list option;
-  destroy : Id.t list option;
+  create : (Proto_id.t * create_args) list option;
+  update : (Proto_id.t * Jsont.json) list option;
+  destroy : Proto_id.t list option;
 }
 
 let set_args_make account_id if_in_state create update destroy =
···
 let set_args_jsont =
   let kind = "PushSubscription/set args" in
   Jsont.Object.map ~kind set_args_make
-  |> Jsont.Object.opt_mem "accountId" Id.jsont ~enc:(fun a -> a.account_id)
+  |> Jsont.Object.opt_mem "accountId" Proto_id.jsont ~enc:(fun a -> a.account_id)
   |> Jsont.Object.opt_mem "ifInState" Jsont.string ~enc:(fun a -> a.if_in_state)
-  |> Jsont.Object.opt_mem "create" (Json_map.of_id create_args_jsont) ~enc:(fun a -> a.create)
-  |> Jsont.Object.opt_mem "update" (Json_map.of_id Jsont.json) ~enc:(fun a -> a.update)
-  |> Jsont.Object.opt_mem "destroy" (Jsont.list Id.jsont) ~enc:(fun a -> a.destroy)
+  |> Jsont.Object.opt_mem "create" (Proto_json_map.of_id create_args_jsont) ~enc:(fun a -> a.create)
+  |> Jsont.Object.opt_mem "update" (Proto_json_map.of_id Jsont.json) ~enc:(fun a -> a.update)
+  |> Jsont.Object.opt_mem "destroy" (Jsont.list Proto_id.jsont) ~enc:(fun a -> a.destroy)
   |> Jsont.Object.finish

proto/push.mli lib/proto/proto_push.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP push types as defined in RFC 8620 Section 7 *)
+(** JMAP push types as defined in RFC 8620 Section 7 
+
+    @canonical Jmap.Proto.Push *)
 
 (** {1 StateChange} *)
 
···
   type t = {
     type_ : string;
     (** Always "StateChange". *)
-    changed : (Id.t * type_state list) list;
+    changed : (Proto_id.t * type_state list) list;
     (** Map of account id to list of type state changes. *)
   }
 
···
 
 (** A push subscription object. *)
 type t = {
-  id : Id.t;
+  id : Proto_id.t;
   (** Server-assigned subscription id. *)
   device_client_id : string;
   (** Client-provided device identifier. *)
···
   (** Data types to receive notifications for. [None] means all. *)
 }
 
-val id : t -> Id.t
+val id : t -> Proto_id.t
 val device_client_id : t -> string
 val url : t -> string
 val keys : t -> push_keys option
···
 (** {1 PushSubscription Methods} *)
 
 (** Arguments for PushSubscription/get. *)
-val get_args_jsont : Method_.get_args Jsont.t
+val get_args_jsont : Proto_method.get_args Jsont.t
 
 (** Response for PushSubscription/get. *)
-val get_response_jsont : t Method_.get_response Jsont.t
+val get_response_jsont : t Proto_method.get_response Jsont.t
 
 (** Arguments for PushSubscription/set. *)
 type set_args = {
-  account_id : Id.t option;
+  account_id : Proto_id.t option;
   (** Not used for PushSubscription. *)
   if_in_state : string option;
-  create : (Id.t * create_args) list option;
-  update : (Id.t * Jsont.json) list option;
-  destroy : Id.t list option;
+  create : (Proto_id.t * create_args) list option;
+  update : (Proto_id.t * Jsont.json) list option;
+  destroy : Proto_id.t list option;
 }
 
 and create_args = {

proto/request.ml lib/proto/proto_request.ml

···
 
 type t = {
   using : string list;
-  method_calls : Invocation.t list;
-  created_ids : (Id.t * Id.t) list option;
+  method_calls : Proto_invocation.t list;
+  created_ids : (Proto_id.t * Proto_id.t) list option;
 }
 
 let create ~using ~method_calls ?created_ids () =
···
   let kind = "Request" in
   Jsont.Object.map ~kind make
   |> Jsont.Object.mem "using" (Jsont.list Jsont.string) ~enc:using
-  |> Jsont.Object.mem "methodCalls" (Jsont.list Invocation.jsont) ~enc:method_calls
-  |> Jsont.Object.opt_mem "createdIds" (Json_map.of_id Id.jsont) ~enc:created_ids
+  |> Jsont.Object.mem "methodCalls" (Jsont.list Proto_invocation.jsont) ~enc:method_calls
+  |> Jsont.Object.opt_mem "createdIds" (Proto_json_map.of_id Proto_id.jsont) ~enc:created_ids
   |> Jsont.Object.finish
 
 let single ~using invocation =

proto/request.mli lib/proto/proto_request.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP request object as defined in RFC 8620 Section 3.3 *)
+(** JMAP request object as defined in RFC 8620 Section 3.3 
+
+    @canonical Jmap.Proto.Request *)
 
 type t = {
   using : string list;
   (** Capability URIs required for this request. *)
-  method_calls : Invocation.t list;
+  method_calls : Proto_invocation.t list;
   (** The method calls to execute. *)
-  created_ids : (Id.t * Id.t) list option;
+  created_ids : (Proto_id.t * Proto_id.t) list option;
   (** Map of client-created temporary ids to server-assigned ids.
       Used for result references in batch operations. *)
 }
 
 val create :
   using:string list ->
-  method_calls:Invocation.t list ->
-  ?created_ids:(Id.t * Id.t) list ->
+  method_calls:Proto_invocation.t list ->
+  ?created_ids:(Proto_id.t * Proto_id.t) list ->
   unit ->
   t
 (** [create ~using ~method_calls ?created_ids ()] creates a JMAP request. *)
 
 val using : t -> string list
-val method_calls : t -> Invocation.t list
-val created_ids : t -> (Id.t * Id.t) list option
+val method_calls : t -> Proto_invocation.t list
+val created_ids : t -> (Proto_id.t * Proto_id.t) list option
 
 val jsont : t Jsont.t
 (** JSON codec for JMAP requests. *)
···
 
 val single :
   using:string list ->
-  Invocation.t ->
+  Proto_invocation.t ->
   t
 (** [single ~using invocation] creates a request with a single method call. *)
 
 val batch :
   using:string list ->
-  Invocation.t list ->
+  Proto_invocation.t list ->
   t
 (** [batch ~using invocations] creates a request with multiple method calls. *)

proto/response.ml lib/proto/proto_response.ml

···
   ---------------------------------------------------------------------------*)
 
 type t = {
-  method_responses : Invocation.t list;
-  created_ids : (Id.t * Id.t) list option;
+  method_responses : Proto_invocation.t list;
+  created_ids : (Proto_id.t * Proto_id.t) list option;
   session_state : string;
 }
 
···
 let jsont =
   let kind = "Response" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "methodResponses" (Jsont.list Invocation.jsont) ~enc:method_responses
-  |> Jsont.Object.opt_mem "createdIds" (Json_map.of_id Id.jsont) ~enc:created_ids
+  |> Jsont.Object.mem "methodResponses" (Jsont.list Proto_invocation.jsont) ~enc:method_responses
+  |> Jsont.Object.opt_mem "createdIds" (Proto_json_map.of_id Proto_id.jsont) ~enc:created_ids
   |> Jsont.Object.mem "sessionState" Jsont.string ~enc:session_state
   |> Jsont.Object.finish
 
 let find_response method_call_id response =
   List.find_opt
-    (fun inv -> Invocation.method_call_id inv = method_call_id)
+    (fun inv -> Proto_invocation.method_call_id inv = method_call_id)
     response.method_responses
 
 let get_response method_call_id response =
···
   | None -> raise Not_found
 
 let is_error invocation =
-  String.equal (Invocation.name invocation) "error"
+  String.equal (Proto_invocation.name invocation) "error"
 
 let get_error invocation =
   if is_error invocation then
-    match Jsont.Json.decode' Error.method_error_jsont (Invocation.arguments invocation) with
+    match Jsont.Json.decode' Proto_error.method_error_jsont (Proto_invocation.arguments invocation) with
     | Ok v -> Some v
     | Error _ -> None
   else

proto/response.mli lib/proto/proto_response.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP response object as defined in RFC 8620 Section 3.4 *)
+(** JMAP response object as defined in RFC 8620 Section 3.4 
+
+    @canonical Jmap.Proto.Response *)
 
 type t = {
-  method_responses : Invocation.t list;
+  method_responses : Proto_invocation.t list;
   (** The method responses. Each is [methodName, responseArgs, methodCallId]. *)
-  created_ids : (Id.t * Id.t) list option;
+  created_ids : (Proto_id.t * Proto_id.t) list option;
   (** Map of client-created temporary ids to server-assigned ids. *)
   session_state : string;
   (** Current session state. Changes indicate session data has changed. *)
 }
 
-val method_responses : t -> Invocation.t list
-val created_ids : t -> (Id.t * Id.t) list option
+val method_responses : t -> Proto_invocation.t list
+val created_ids : t -> (Proto_id.t * Proto_id.t) list option
 val session_state : t -> string
 
 val jsont : t Jsont.t
···
 
 (** {1 Response Inspection} *)
 
-val find_response : string -> t -> Invocation.t option
+val find_response : string -> t -> Proto_invocation.t option
 (** [find_response method_call_id response] finds the response for a method call. *)
 
-val get_response : string -> t -> Invocation.t
+val get_response : string -> t -> Proto_invocation.t
 (** [get_response method_call_id response] gets the response for a method call.
     @raise Not_found if not found. *)
 
-val is_error : Invocation.t -> bool
+val is_error : Proto_invocation.t -> bool
 (** [is_error invocation] returns [true] if the invocation is an error response. *)
 
-val get_error : Invocation.t -> Error.method_error option
+val get_error : Proto_invocation.t -> Proto_error.method_error option
 (** [get_error invocation] returns the error if this is an error response. *)

proto/session.ml lib/proto/proto_session.ml

···
     |> Jsont.Object.mem "name" Jsont.string ~enc:name
     |> Jsont.Object.mem "isPersonal" Jsont.bool ~enc:is_personal
     |> Jsont.Object.mem "isReadOnly" Jsont.bool ~enc:is_read_only
-    |> Jsont.Object.mem "accountCapabilities" (Json_map.of_string Jsont.json) ~enc:account_capabilities
+    |> Jsont.Object.mem "accountCapabilities" (Proto_json_map.of_string Jsont.json) ~enc:account_capabilities
     |> Jsont.Object.finish
 end
 
 type t = {
   capabilities : (string * Jsont.json) list;
-  accounts : (Id.t * Account.t) list;
-  primary_accounts : (string * Id.t) list;
+  accounts : (Proto_id.t * Account.t) list;
+  primary_accounts : (string * Proto_id.t) list;
   username : string;
   api_url : string;
   download_url : string;
···
 let jsont =
   let kind = "Session" in
   Jsont.Object.map ~kind make
-  |> Jsont.Object.mem "capabilities" (Json_map.of_string Jsont.json) ~enc:capabilities
-  |> Jsont.Object.mem "accounts" (Json_map.of_id Account.jsont) ~enc:accounts
-  |> Jsont.Object.mem "primaryAccounts" (Json_map.of_string Id.jsont) ~enc:primary_accounts
+  |> Jsont.Object.mem "capabilities" (Proto_json_map.of_string Jsont.json) ~enc:capabilities
+  |> Jsont.Object.mem "accounts" (Proto_json_map.of_id Account.jsont) ~enc:accounts
+  |> Jsont.Object.mem "primaryAccounts" (Proto_json_map.of_string Proto_id.jsont) ~enc:primary_accounts
   |> Jsont.Object.mem "username" Jsont.string ~enc:username
   |> Jsont.Object.mem "apiUrl" Jsont.string ~enc:api_url
   |> Jsont.Object.mem "downloadUrl" Jsont.string ~enc:download_url
···
   List.exists (fun (k, _) -> k = uri) session.capabilities
 
 let get_core_capability session =
-  match List.assoc_opt Capability.core session.capabilities with
+  match List.assoc_opt Proto_capability.core session.capabilities with
   | None -> None
   | Some json ->
-    (match Jsont.Json.decode' Capability.Core.jsont json with
+    (match Jsont.Json.decode' Proto_capability.Core.jsont json with
      | Ok v -> Some v
      | Error _ -> None)
 
 let get_mail_capability session =
-  match List.assoc_opt Capability.mail session.capabilities with
+  match List.assoc_opt Proto_capability.mail session.capabilities with
   | None -> None
   | Some json ->
-    (match Jsont.Json.decode' Capability.Mail.jsont json with
+    (match Jsont.Json.decode' Proto_capability.Mail.jsont json with
      | Ok v -> Some v
      | Error _ -> None)

proto/session.mli lib/proto/proto_session.mli

···
    SPDX-License-Identifier: ISC
   ---------------------------------------------------------------------------*)
 
-(** JMAP session object as defined in RFC 8620 Section 2 *)
+(** JMAP session object as defined in RFC 8620 Section 2 
+
+    @canonical Jmap.Proto.Session *)
 
 (** {1 Account} *)
 
···
 type t = {
   capabilities : (string * Jsont.json) list;
   (** Server capabilities. Keys are capability URIs. *)
-  accounts : (Id.t * Account.t) list;
+  accounts : (Proto_id.t * Account.t) list;
   (** Available accounts keyed by account id. *)
-  primary_accounts : (string * Id.t) list;
+  primary_accounts : (string * Proto_id.t) list;
   (** Map of capability URI to the primary account id for that capability. *)
   username : string;
   (** The username associated with the credentials. *)
···
 }
 
 val capabilities : t -> (string * Jsont.json) list
-val accounts : t -> (Id.t * Account.t) list
-val primary_accounts : t -> (string * Id.t) list
+val accounts : t -> (Proto_id.t * Account.t) list
+val primary_accounts : t -> (string * Proto_id.t) list
 val username : t -> string
 val api_url : t -> string
 val download_url : t -> string
···
 
 (** {1 Session Helpers} *)
 
-val get_account : Id.t -> t -> Account.t option
+val get_account : Proto_id.t -> t -> Account.t option
 (** [get_account id session] returns the account with the given id. *)
 
-val primary_account_for : string -> t -> Id.t option
+val primary_account_for : string -> t -> Proto_id.t option
 (** [primary_account_for capability session] returns the primary account
     for the given capability URI. *)
 
 val has_capability : string -> t -> bool
 (** [has_capability uri session] returns [true] if the server supports the capability. *)
 
-val get_core_capability : t -> Capability.Core.t option
+val get_core_capability : t -> Proto_capability.Core.t option
 (** [get_core_capability session] returns the parsed core capability. *)
 
-val get_mail_capability : t -> Capability.Mail.t option
+val get_mail_capability : t -> Proto_capability.Mail.t option
 (** [get_mail_capability session] returns the parsed mail capability. *)

proto/unknown.mli lib/proto/proto_unknown.mli

···
 (** Unknown field preservation for forward compatibility.
 
     All JMAP objects preserve unknown fields to support future spec versions
-    and custom extensions. *)
+    and custom extensions. 
+
+    @canonical Jmap.Proto.Unknown *)
 
 type t = Jsont.json
 (** Unknown or unrecognized JSON object members as a generic JSON value.

test/proto/dune

···
 (test
  (name test_proto)
  (package jmap)
- (libraries jmap jmap.mail alcotest jsont.bytesrw)
+ (libraries jmap alcotest jsont.bytesrw)
  (deps
   (source_tree id)
   (source_tree int53)

test/proto/test_proto.ml

···
 
 (* ID tests *)
 module Id_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_valid_simple () =
     let json = "\"abc123\"" in
···
 
 (* Int53 tests *)
 module Int53_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_zero () =
     match decode Int53.Signed.jsont "0" with
···
 
 (* Date tests *)
 module Date_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_utc_z () =
     match decode Date.Utc.jsont "\"2024-01-15T10:30:00Z\"" with
···
 
 (* Session tests *)
 module Session_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_minimal () =
     test_decode_success "minimal session" Session.jsont "session/valid/minimal.json" ()
···
 
 (* Request tests *)
 module Request_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_single_method () =
     test_decode_success "single method" Request.jsont "request/valid/single_method.json" ()
···
 
 (* Response tests *)
 module Response_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_success () =
     test_decode_success "success" Response.jsont "response/valid/success.json" ()
···
 
 (* Invocation tests *)
 module Invocation_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_get () =
     test_decode_success "get" Invocation.jsont "invocation/valid/get.json" ()
···
 
 (* Capability tests *)
 module Capability_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_core () =
     test_decode_success "core" Capability.Core.jsont "capability/valid/core.json" ()
···
 
 (* Method args/response tests *)
 module Method_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_get_args () =
     test_decode_success "get_args" Method.get_args_jsont "method/valid/get_args.json" ()
···
 
 (* Error tests *)
 module Error_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_method_error () =
     test_decode_success "method_error" Error.method_error_jsont "error/valid/method_error.json" ()
···
 
 (* Mailbox tests *)
 module Mailbox_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let role_testable =
     Alcotest.testable
···
     match decode Mailbox.jsont json with
     | Error e -> Alcotest.failf "decode failed: %s" (Jsont.Error.to_string e)
     | Ok mb ->
-        Alcotest.(check string) "id" "mb1" (Jmap_proto.Id.to_string (Mailbox.id mb));
+        Alcotest.(check string) "id" "mb1" (Jmap.Proto.Id.to_string (Mailbox.id mb));
         Alcotest.(check string) "name" "Inbox" (Mailbox.name mb);
         Alcotest.(check (option role_testable)) "role" (Some Mailbox.Inbox) (Mailbox.role mb);
         Alcotest.(check int64) "totalEmails" 150L (Mailbox.total_emails mb);
···
 
 (* Email tests *)
 module Email_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_minimal () =
     test_decode_success "minimal" Email.jsont "mail/email/valid/minimal.json" ()
···
     match decode Email.jsont json with
     | Error e -> Alcotest.failf "decode failed: %s" (Jsont.Error.to_string e)
     | Ok email ->
-        Alcotest.(check string) "id" "e1" (Jmap_proto.Id.to_string (Email.id email));
-        Alcotest.(check string) "blobId" "blob1" (Jmap_proto.Id.to_string (Email.blob_id email));
+        Alcotest.(check string) "id" "e1" (Jmap.Proto.Id.to_string (Email.id email));
+        Alcotest.(check string) "blobId" "blob1" (Jmap.Proto.Id.to_string (Email.blob_id email));
         Alcotest.(check int64) "size" 1024L (Email.size email)
 
   let test_full_values () =
···
 
 (* Thread tests *)
 module Thread_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_simple () =
     test_decode_success "simple" Thread.jsont "mail/thread/valid/simple.json" ()
···
     match decode Thread.jsont json with
     | Error e -> Alcotest.failf "decode failed: %s" (Jsont.Error.to_string e)
     | Ok thread ->
-        Alcotest.(check string) "id" "t2" (Jmap_proto.Id.to_string (Thread.id thread));
+        Alcotest.(check string) "id" "t2" (Jmap.Proto.Id.to_string (Thread.id thread));
         Alcotest.(check int) "emailIds count" 5 (List.length (Thread.email_ids thread))
 
   let tests = [
···
 
 (* Identity tests *)
 module Identity_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_simple () =
     test_decode_success "simple" Identity.jsont "mail/identity/valid/simple.json" ()
···
 
 (* Email address tests *)
 module Email_address_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_full () =
     test_decode_success "full" Email_address.jsont "mail/email_address/valid/full.json" ()
···
 
 (* Vacation tests *)
 module Vacation_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_enabled () =
     test_decode_success "enabled" Vacation.jsont "mail/vacation/valid/enabled.json" ()
···
 
 (* Comparator tests *)
 module Comparator_tests = struct
-  open Jmap_proto
+  open Jmap.Proto
 
   let test_minimal () =
     test_decode_success "minimal" Filter.comparator_jsont "filter/valid/comparator_minimal.json" ()
···
 
 (* EmailBody tests *)
 module EmailBody_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_text_part () =
     test_decode_success "text part" Email_body.Part.jsont "mail/email_body/valid/text_part.json" ()
···
 
 (* EmailSubmission tests *)
 module EmailSubmission_tests = struct
-  open Jmap_mail
+  open Jmap.Proto
 
   let test_simple () =
     test_decode_success "simple" Submission.jsont "mail/submission/valid/simple.json" ()
···
     match decode Submission.jsont json with
     | Error e -> Alcotest.failf "decode failed: %s" (Jsont.Error.to_string e)
     | Ok sub ->
-        Alcotest.(check string) "id" "sub1" (Jmap_proto.Id.to_string (Submission.id sub));
+        Alcotest.(check string) "id" "sub1" (Jmap.Proto.Id.to_string (Submission.id sub));
         (* Check undoStatus is Pending *)
         match Submission.undo_status sub with
         | Submission.Pending -> ()