Add default values, validation, and field-level unions to OpenAPI generator

- Add default value support: extract JSON defaults and generate OCaml literals
for bools, ints, floats, strings, enums, null, and empty arrays
- Generate constructors with optional params using ?(name=default) syntax
- Generate jsont codecs with ~dec_absent:default for absent field handling
- Add runtime validation for strings (minLength, maxLength, pattern),
numbers (minimum, maximum, exclusiveMinimum, exclusiveMaximum),
and lists (minItems, maxItems, uniqueItems)
- Add field-level union types for primitive oneOf/anyOf schemas
- Handle forward references in circular dependencies with Jsont.json fallback
- Improve topological sort to handle cycles gracefully
- Regenerate immich and peertube clients with new features

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

dune

···
 (library
- (name peertube)
+ (name peer_tube)
  (public_name peertube)
  (libraries openapi jsont jsont.bytesrw requests ptime eio)
  (wrapped true))

peertube.ml peer_tube.ml

···
-(** {1 Peertube}
+(** {1 PeerTube}
 
     The PeerTube API is built on HTTP(S) and is RESTful. You can use your favorite
 HTTP/REST library for your programming language to use PeerTube.
···
 let session t = t.session
 
 module VideosForXml = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoUpload = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        video : Jsont.json option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      video : Jsont.json option;
-    }
+    include Types.Response
     
     let v ?video () = { video }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a live *)
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Upload a video
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Send chunk for the resumable upload of a video
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoToken = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        files : Jsont.json option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      files : Jsont.json option;
-    }
+    include Types.Response
     
     let v ?files () = { files }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoStudioCreateTask = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoStatsUserAgentDevice = struct
+  module Types = struct
+    module T = struct
+      type t = [
+        | `Console
+        | `Embedded
+        | `Mobile
+        | `Smarttv
+        | `Tablet
+        | `Wearable
+        | `Xr
+        | `Desktop
+      ]
+    end
+  end
+  
   module T = struct
-    type t = [
-      | `Console
-      | `Embedded
-      | `Mobile
-      | `Smarttv
-      | `Tablet
-      | `Wearable
-      | `Xr
-      | `Desktop
-    ]
+    include Types.T
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"VideoStatsUserAgentDevice"
···
 end
 
 module UserViewingVideo = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        client : string option;  (** Client software used to watch the video. For example "Firefox", "PeerTube Approval Android", etc.
+       *)
+        current_time : int;  (** timestamp within the video, in seconds *)
+        device : VideoStatsUserAgentDevice.T.t option;  (** Device used to watch the video. For example "desktop", "mobile", "smarttv", etc.
+       *)
+        operating_system : string option;  (** Operating system used to watch the video. For example "Windows", "Ubuntu", etc.
+       *)
+        session_id : string option;  (** Optional param to represent the current viewer session. Used by the backend to properly count one view per session per video. PeerTube admin can configure the server to not trust this `sessionId` parameter but use the request IP address instead to identify a viewer.
+       *)
+        view_event : string option;  (** Event since last viewing call:
+       * `seek` - If the user seeked the video
+       *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      client : string option;  (** Client software used to watch the video. For example "Firefox", "PeerTube Approval Android", etc.
-     *)
-      current_time : int;  (** timestamp within the video, in seconds *)
-      device : VideoStatsUserAgentDevice.T.t option;  (** Device used to watch the video. For example "desktop", "mobile", "smarttv", etc.
-     *)
-      operating_system : string option;  (** Operating system used to watch the video. For example "Windows", "Ubuntu", etc.
-     *)
-      session_id : string option;  (** Optional param to represent the current viewer session. Used by the backend to properly count one view per session per video. PeerTube admin can configure the server to not trust this `sessionId` parameter but use the request IP address instead to identify a viewer.
-     *)
-      view_event : string option;  (** Event since last viewing call:
-     * `seek` - If the user seeked the video
-     *)
-    }
+    include Types.T
     
     let v ~current_time ?client ?device ?operating_system ?session_id ?view_event () = { client; current_time; device; operating_system; session_id; view_event }
     
···
 end
 
 module VideoStatsUserAgent = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        clients : Jsont.json list option;
+        devices : Jsont.json list option;
+        operating_system : Jsont.json list option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      clients : Jsont.json list option;
-      devices : Jsont.json list option;
-      operating_system : Jsont.json list option;
-    }
+    include Types.T
     
     let v ?clients ?devices ?operating_system () = { clients; devices; operating_system }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoStatsTimeserie = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : Jsont.json list option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : Jsont.json list option;
-    }
+    include Types.T
     
     let v ?data () = { data }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoStatsRetention = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : Jsont.json list option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : Jsont.json list option;
-    }
+    include Types.T
     
     let v ?data () = { data }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoStatsOverall = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        average_watch_time : float option;
+        countries : Jsont.json list option;
+        subdivisions : Jsont.json list option;
+        total_viewers : float option;
+        total_watch_time : float option;
+        viewers_peak : float option;
+        viewers_peak_date : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      average_watch_time : float option;
-      countries : Jsont.json list option;
-      subdivisions : Jsont.json list option;
-      total_viewers : float option;
-      total_watch_time : float option;
-      viewers_peak : float option;
-      viewers_peak_date : Ptime.t option;
-    }
+    include Types.T
     
     let v ?average_watch_time ?countries ?subdivisions ?total_viewers ?total_watch_time ?viewers_peak ?viewers_peak_date () = { average_watch_time; countries; subdivisions; total_viewers; total_watch_time; viewers_peak; viewers_peak_date }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoStateConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : int option;  (** The video state:
+      - `1`: Published
+      - `2`: To transcode
+      - `3`: To import
+      - `4`: Waiting for live stream
+      - `5`: Live ended
+      - `6`: To move to an external storage (object storage...)
+      - `7`: Transcoding failed
+      - `8`: Moving to an external storage failed
+      - `9`: To edit using studio edition feature
+       *)
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : int option;  (** The video state:
-    - `1`: Published
-    - `2`: To transcode
-    - `3`: To import
-    - `4`: Waiting for live stream
-    - `5`: Live ended
-    - `6`: To move to an external storage (object storage...)
-    - `7`: Transcoding failed
-    - `8`: Moving to an external storage failed
-    - `9`: To edit using studio edition feature
-     *)
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoResolutionSet = struct
+  module Types = struct
+    module T = struct
+      (** Video resolution (`0`, `240`, `360`, `720`, `1080`, `1440` or `2160`)
+      
+      `0` is used as a special value for stillimage videos dedicated to audio, a.k.a. audio-only videos.
+       *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** Video resolution (`0`, `240`, `360`, `720`, `1080`, `1440` or `2160`)
-    
-    `0` is used as a special value for stillimage videos dedicated to audio, a.k.a. audio-only videos.
-     *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoResolutionConstant = struct
+  module Types = struct
+    module T = struct
+      (** resolutions and their labels for the video *)
+      type t = {
+        id : VideoResolutionSet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    (** resolutions and their labels for the video *)
-    type t = {
-      id : VideoResolutionSet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoSource = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        file_download_url : string option;  (** **PeerTube >= 6.1** If enabled by the admin, the video source file is kept on the server and can be downloaded by the owner *)
+        fps : float option;  (** **PeerTube >= 6.1** Frames per second of the video file *)
+        height : int option;  (** **PeerTube >= 6.1** Video stream height *)
+        input_filename : string option;  (** Uploaded/imported filename *)
+        resolution : VideoResolutionConstant.T.t option;  (** **PeerTube >= 6.1** *)
+        size : int option;  (** **PeerTube >= 6.1** Video file size in bytes *)
+        width : int option;  (** **PeerTube >= 6.1** Video stream width *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      file_download_url : string option;  (** **PeerTube >= 6.1** If enabled by the admin, the video source file is kept on the server and can be downloaded by the owner *)
-      fps : float option;  (** **PeerTube >= 6.1** Frames per second of the video file *)
-      height : int option;  (** **PeerTube >= 6.1** Video stream height *)
-      input_filename : string option;  (** Uploaded/imported filename *)
-      resolution : VideoResolutionConstant.T.t option;  (** **PeerTube >= 6.1** *)
-      size : int option;  (** **PeerTube >= 6.1** Video file size in bytes *)
-      width : int option;  (** **PeerTube >= 6.1** Video stream width *)
-    }
+    include Types.T
     
     let v ?created_at ?file_download_url ?fps ?height ?input_filename ?resolution ?size ?width () = { created_at; file_download_url; fps; height; input_filename; resolution; size; width }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoReplaceSourceRequestResumable = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        filename : string option;  (** Video filename including extension *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      filename : string option;  (** Video filename including extension *)
-    }
+    include Types.T
     
     let v ?filename () = { filename }
     
···
 end
 
 module VideoPrivacySet = struct
+  module Types = struct
+    module T = struct
+      (** privacy id of the video (see [/videos/privacies](#operation/getVideoPrivacyPolicies)) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** privacy id of the video (see [/videos/privacies](#operation/getVideoPrivacyPolicies)) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoScheduled = struct
+  module Types = struct
+    module Update = struct
+      type t = {
+        privacy : VideoPrivacySet.T.t option;
+        update_at : Ptime.t;  (** When to update the video *)
+      }
+    end
+  end
+  
   module Update = struct
-    type t = {
-      privacy : VideoPrivacySet.T.t option;
-      update_at : Ptime.t;  (** When to update the video *)
-    }
+    include Types.Update
     
     let v ~update_at ?privacy () = { privacy; update_at }
     
···
 end
 
 module VideoPrivacyConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoPrivacySet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoPrivacySet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module LiveVideoReplaySettings = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        privacy : VideoPrivacySet.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      privacy : VideoPrivacySet.T.t option;
-    }
+    include Types.T
     
     let v ?privacy () = { privacy }
     
···
 end
 
 module VideoPlaylistTypeSet = struct
+  module Types = struct
+    module T = struct
+      (** The video playlist type (Regular = `1`, Watch Later = `2`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The video playlist type (Regular = `1`, Watch Later = `2`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoPlaylistTypeConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoPlaylistTypeSet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoPlaylistTypeSet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoPlaylistPrivacySet = struct
+  module Types = struct
+    module T = struct
+      (** Video playlist privacy policy (see [/video-playlists/privacies](#operation/getPlaylistPrivacyPolicies)) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** Video playlist privacy policy (see [/video-playlists/privacies](#operation/getPlaylistPrivacyPolicies)) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoPlaylistPrivacyConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoPlaylistPrivacySet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoPlaylistPrivacySet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoLicenceSet = struct
+  module Types = struct
+    module T = struct
+      (** licence id of the video (see [/videos/licences](#operation/getLicences)) *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** licence id of the video (see [/videos/licences](#operation/getLicences)) *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoConstantNumberLicence = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoLicenceSet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoLicenceSet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoLanguageSet = struct
+  module Types = struct
+    module T = struct
+      (** language id of the video (see [/videos/languages](#operation/getLanguages)) *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** language id of the video (see [/videos/languages](#operation/getLanguages)) *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoConstantStringLanguage = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoLanguageSet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoLanguageSet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoCaption = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        automatically_generated : bool option;
+        caption_path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
+        file_url : string option;  (** **PeerTube >= 7.1** *)
+        language : VideoConstantStringLanguage.T.t option;
+        m3u8_url : string option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      automatically_generated : bool option;
-      caption_path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
-      file_url : string option;  (** **PeerTube >= 7.1** *)
-      language : VideoConstantStringLanguage.T.t option;
-      m3u8_url : string option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?automatically_generated ?caption_path ?file_url ?language ?m3u8_url ?updated_at () = { automatically_generated; caption_path; file_url; language; m3u8_url; updated_at }
     
···
 end
 
 module VideoImportStateConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : int option;  (** The video import state (Pending = `1`, Success = `2`, Failed = `3`) *)
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : int option;  (** The video import state (Pending = `1`, Success = `2`, Failed = `3`) *)
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoCommentsPolicySet = struct
+  module Types = struct
+    module T = struct
+      (** Comments policy of the video (Enabled = `1`, Disabled = `2`, Requires Approval = `3`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** Comments policy of the video (Enabled = `1`, Disabled = `2`, Requires Approval = `3`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoCommentsPolicyConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoCommentsPolicySet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoCommentsPolicySet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module VideoCommentsForXml = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoChapters = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        chapters : Jsont.json option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      chapters : Jsont.json option;
-    }
+    include Types.T
     
     let v ?chapters () = { chapters }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoChannelEdit = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        description : Jsont.json option;  (** Channel description *)
+        display_name : Jsont.json option;  (** Channel display name *)
+        support : Jsont.json option;  (** How to support/fund the channel *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      description : Jsont.json option;  (** Channel description *)
-      display_name : Jsont.json option;  (** Channel display name *)
-      support : Jsont.json option;  (** How to support/fund the channel *)
-    }
+    include Types.T
     
     let v ?description ?display_name ?support () = { description; display_name; support }
     
···
 end
 
 module VideoChannelCollaboratorState = struct
+  module Types = struct
+    module T = struct
+      (** The user import state:
+        - `1`: Pending
+        - `2`: Accepted
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The user import state:
-      - `1`: Pending
-      - `2`: Accepted
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoChannelActivityTarget = struct
+  module Types = struct
+    module T = struct
+      (** The activity target:
+        - VIDEO: 1,
+        - PLAYLIST: 2,
+        - CHANNEL: 3,
+        - CHANNEL_SYNC: 4,
+        - VIDEO_IMPORT: 5
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The activity target:
-      - VIDEO: 1,
-      - PLAYLIST: 2,
-      - CHANNEL: 3,
-      - CHANNEL_SYNC: 4,
-      - VIDEO_IMPORT: 5
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoChannelActivityAction = struct
+  module Types = struct
+    module T = struct
+      (** The activity action:
+        - CREATE: 1
+        - UPDATE: 2
+        - DELETE: 3
+        - UPDATE_CAPTIONS: 4
+        - UPDATE_CHAPTERS: 5
+        - UPDATE_PASSWORDS: 6
+        - CREATE_STUDIO_TASKS: 7
+        - UPDATE_SOURCE_FILE: 8
+        - UPDATE_ELEMENTS: 9
+        - REMOVE_CHANNEL_OWNERSHIP: 10
+        - CREATE_CHANNEL_OWNERSHIP: 11
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The activity action:
-      - CREATE: 1
-      - UPDATE: 2
-      - DELETE: 3
-      - UPDATE_CAPTIONS: 4
-      - UPDATE_CHAPTERS: 5
-      - UPDATE_PASSWORDS: 6
-      - CREATE_STUDIO_TASKS: 7
-      - UPDATE_SOURCE_FILE: 8
-      - UPDATE_ELEMENTS: 9
-      - REMOVE_CHANNEL_OWNERSHIP: 10
-      - CREATE_CHANNEL_OWNERSHIP: 11
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoCategorySet = struct
+  module Types = struct
+    module T = struct
+      (** category id of the video (see [/videos/categories](#operation/getCategories)) *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** category id of the video (see [/videos/categories](#operation/getCategories)) *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoConstantNumberCategory = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : VideoCategorySet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : VideoCategorySet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module Uuidv4 = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module UsernameChannel = struct
+  module Types = struct
+    module T = struct
+      (** immutable name of the channel, used to interact with its actor *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** immutable name of the channel, used to interact with its actor *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module Username = struct
+  module Types = struct
+    module T = struct
+      (** immutable name of the user, used to find or mention its actor *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** immutable name of the user, used to find or mention its actor *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module UserRole = struct
+  module Types = struct
+    module T = struct
+      (** The user role (Admin = `0`, Moderator = `1`, User = `2`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The user role (Admin = `0`, Moderator = `1`, User = `2`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module UserRegistrationAcceptOrReject = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        moderation_response : string;  (** Moderation response to send to the user *)
+        prevent_email_delivery : bool option;  (** Set it to true if you don't want PeerTube to send an email to the user *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      moderation_response : string;  (** Moderation response to send to the user *)
-      prevent_email_delivery : bool option;  (** Set it to true if you don't want PeerTube to send an email to the user *)
-    }
+    include Types.T
     
     let v ~moderation_response ?prevent_email_delivery () = { moderation_response; prevent_email_delivery }
     
···
 end
 
 module UserImportState = struct
+  module Types = struct
+    module T = struct
+      (** The user import state:
+        - `1`: Pending
+        - `2`: Processing
+        - `3`: Completed
+        - `4`: Errored
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The user import state:
-      - `1`: Pending
-      - `2`: Processing
-      - `3`: Completed
-      - `4`: Errored
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module UserImportResumable = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        filename : string option;  (** Archive filename including extension *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      filename : string option;  (** Archive filename including extension *)
-    }
+    include Types.T
     
     let v ?filename () = { filename }
     
···
 end
 
 module UserExportState = struct
+  module Types = struct
+    module T = struct
+      (** The user export state:
+        - `1`: Pending
+        - `2`: Processing
+        - `3`: Completed
+        - `4`: Errored
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The user export state:
-      - `1`: Pending
-      - `2`: Processing
-      - `3`: Completed
-      - `4`: Errored
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module UserAdminFlags = struct
+  module Types = struct
+    module T = struct
+      (** Admin flags for the user (None = `0`, Bypass video blocklist = `1`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** Admin flags for the user (None = `0`, Bypass video blocklist = `1`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module TokenSession = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        current_session : bool option;  (** Is this session the current one? *)
+        id : int option;
+        last_activity_date : Ptime.t option;
+        last_activity_device : string option;
+        last_activity_ip : string option;
+        login_date : Ptime.t option;  (** Date of the login *)
+        login_device : string option;  (** Device used to login *)
+        login_ip : string option;  (** IP address used to login *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      current_session : bool option;  (** Is this session the current one? *)
-      id : int option;
-      last_activity_date : Ptime.t option;
-      last_activity_device : string option;
-      last_activity_ip : string option;
-      login_date : Ptime.t option;  (** Date of the login *)
-      login_device : string option;  (** Device used to login *)
-      login_ip : string option;  (** IP address used to login *)
-    }
+    include Types.T
     
     let v ?created_at ?current_session ?id ?last_activity_date ?last_activity_device ?last_activity_ip ?login_date ?login_device ?login_ip () = { created_at; current_session; id; last_activity_date; last_activity_device; last_activity_ip; login_date; login_device; login_ip }
     
···
 end
 
 module Storyboard = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        file_url : string option;  (** **PeerTube >= 7.1** *)
+        sprite_duration : int option;
+        sprite_height : int option;
+        sprite_width : int option;
+        storyboard_path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
+        total_height : int option;
+        total_width : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      file_url : string option;  (** **PeerTube >= 7.1** *)
-      sprite_duration : int option;
-      sprite_height : int option;
-      sprite_width : int option;
-      storyboard_path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
-      total_height : int option;
-      total_width : int option;
-    }
+    include Types.T
     
     let v ?file_url ?sprite_duration ?sprite_height ?sprite_width ?storyboard_path ?total_height ?total_width () = { file_url; sprite_duration; sprite_height; sprite_width; storyboard_path; total_height; total_width }
     
···
 end
 
 module ShortUuid = struct
+  module Types = struct
+    module T = struct
+      (** translation of a uuid v4 with a bigger alphabet to have a shorter uuid *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** translation of a uuid v4 with a bigger alphabet to have a shorter uuid *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module ServerStats = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        activity_pub_messages_processed_per_second : float option;
+        average_abuse_response_time_ms : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
+        average_registration_request_response_time_ms : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
+        total_abuses : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
+        total_abuses_processed : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
+        total_activity_pub_messages_errors : float option;
+        total_activity_pub_messages_processed : float option;
+        total_activity_pub_messages_successes : float option;
+        total_activity_pub_messages_waiting : float option;
+        total_admins : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled total admins stats *)
+        total_daily_active_users : float option;
+        total_instance_followers : float option;
+        total_instance_following : float option;
+        total_local_daily_active_video_channels : float option;
+        total_local_monthly_active_video_channels : float option;
+        total_local_playlists : float option;
+        total_local_video_channels : float option;
+        total_local_video_comments : float option;  (** Total comments made by local users *)
+        total_local_video_files_size : float option;
+        total_local_video_views : float option;  (** Total video views made on the instance *)
+        total_local_videos : float option;
+        total_local_weekly_active_video_channels : float option;
+        total_moderators : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled total moderators stats *)
+        total_monthly_active_users : float option;
+        total_registration_requests : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
+        total_registration_requests_processed : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
+        total_users : float option;
+        total_video_comments : float option;
+        total_videos : float option;
+        total_weekly_active_users : float option;
+        videos_redundancy : Jsont.json list option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      activity_pub_messages_processed_per_second : float option;
-      average_abuse_response_time_ms : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
-      average_registration_request_response_time_ms : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
-      total_abuses : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
-      total_abuses_processed : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled abuses stats *)
-      total_activity_pub_messages_errors : float option;
-      total_activity_pub_messages_processed : float option;
-      total_activity_pub_messages_successes : float option;
-      total_activity_pub_messages_waiting : float option;
-      total_admins : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled total admins stats *)
-      total_daily_active_users : float option;
-      total_instance_followers : float option;
-      total_instance_following : float option;
-      total_local_daily_active_video_channels : float option;
-      total_local_monthly_active_video_channels : float option;
-      total_local_playlists : float option;
-      total_local_video_channels : float option;
-      total_local_video_comments : float option;  (** Total comments made by local users *)
-      total_local_video_files_size : float option;
-      total_local_video_views : float option;  (** Total video views made on the instance *)
-      total_local_videos : float option;
-      total_local_weekly_active_video_channels : float option;
-      total_moderators : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled total moderators stats *)
-      total_monthly_active_users : float option;
-      total_registration_requests : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
-      total_registration_requests_processed : float option;  (** **PeerTube >= 6.1** Value is null if the admin disabled registration requests stats *)
-      total_users : float option;
-      total_video_comments : float option;
-      total_videos : float option;
-      total_weekly_active_users : float option;
-      videos_redundancy : Jsont.json list option;
-    }
+    include Types.T
     
     let v ?activity_pub_messages_processed_per_second ?average_abuse_response_time_ms ?average_registration_request_response_time_ms ?total_abuses ?total_abuses_processed ?total_activity_pub_messages_errors ?total_activity_pub_messages_processed ?total_activity_pub_messages_successes ?total_activity_pub_messages_waiting ?total_admins ?total_daily_active_users ?total_instance_followers ?total_instance_following ?total_local_daily_active_video_channels ?total_local_monthly_active_video_channels ?total_local_playlists ?total_local_video_channels ?total_local_video_comments ?total_local_video_files_size ?total_local_video_views ?total_local_videos ?total_local_weekly_active_video_channels ?total_moderators ?total_monthly_active_users ?total_registration_requests ?total_registration_requests_processed ?total_users ?total_video_comments ?total_videos ?total_weekly_active_users ?videos_redundancy () = { activity_pub_messages_processed_per_second; average_abuse_response_time_ms; average_registration_request_response_time_ms; total_abuses; total_abuses_processed; total_activity_pub_messages_errors; total_activity_pub_messages_processed; total_activity_pub_messages_successes; total_activity_pub_messages_waiting; total_admins; total_daily_active_users; total_instance_followers; total_instance_following; total_local_daily_active_video_channels; total_local_monthly_active_video_channels; total_local_playlists; total_local_video_channels; total_local_video_comments; total_local_video_files_size; total_local_video_views; total_local_videos; total_local_weekly_active_video_channels; total_moderators; total_monthly_active_users; total_registration_requests; total_registration_requests_processed; total_users; total_video_comments; total_videos; total_weekly_active_users; videos_redundancy }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module ServerError = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        code : string option;
+        detail : string option;
+        status : int option;
+        type_ : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      code : string option;
-      detail : string option;
-      status : int option;
-      type_ : string option;
-    }
+    include Types.T
     
     let v ?code ?detail ?status ?type_ () = { code; detail; status; type_ }
     
···
 end
 
 module ServerConfigCustom = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        admin : Jsont.json option;
+        auto_blacklist : Jsont.json option;
+        cache : Jsont.json option;
+        contact_form : Jsont.json option;
+        defaults : Jsont.json option;
+        followers : Jsont.json option;
+        import : Jsont.json option;
+        instance : Jsont.json option;
+        services : Jsont.json option;
+        signup : Jsont.json option;
+        storyboard : Jsont.json option;
+        theme : Jsont.json option;
+        transcoding : Jsont.json option;  (** Settings pertaining to transcoding jobs *)
+        user : Jsont.json option;  (** Settings that apply to new users, if registration is enabled *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      admin : Jsont.json option;
-      auto_blacklist : Jsont.json option;
-      cache : Jsont.json option;
-      contact_form : Jsont.json option;
-      defaults : Jsont.json option;
-      followers : Jsont.json option;
-      import : Jsont.json option;
-      instance : Jsont.json option;
-      services : Jsont.json option;
-      signup : Jsont.json option;
-      storyboard : Jsont.json option;
-      theme : Jsont.json option;
-      transcoding : Jsont.json option;  (** Settings pertaining to transcoding jobs *)
-      user : Jsont.json option;  (** Settings that apply to new users, if registration is enabled *)
-    }
+    include Types.T
     
     let v ?admin ?auto_blacklist ?cache ?contact_form ?defaults ?followers ?import ?instance ?services ?signup ?storyboard ?theme ?transcoding ?user () = { admin; auto_blacklist; cache; contact_form; defaults; followers; import; instance; services; signup; storyboard; theme; transcoding; user }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module ServerConfigAbout = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        instance : Jsont.json option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      instance : Jsont.json option;
-    }
+    include Types.T
     
     let v ?instance () = { instance }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module Server = struct
+  module Types = struct
+    module Config = struct
+      type t = {
+        auto_blacklist : Jsont.json option;
+        avatar : Jsont.json option;
+        contact_form : Jsont.json option;
+        email : Jsont.json option;
+        export : Jsont.json option;
+        federation : Jsont.json option;
+        followings : Jsont.json option;
+        homepage : Jsont.json option;
+        import : Jsont.json option;
+        instance : Jsont.json option;
+        open_telemetry : Jsont.json option;  (** PeerTube >= 6.1 *)
+        plugin : Jsont.json option;
+        search : Jsont.json option;
+        server_commit : string option;
+        server_version : string option;
+        signup : Jsont.json option;
+        theme : Jsont.json option;
+        tracker : Jsont.json option;
+        transcoding : Jsont.json option;
+        trending : Jsont.json option;
+        user : Jsont.json option;
+        video : Jsont.json option;
+        video_caption : Jsont.json option;
+        views : Jsont.json option;  (** PeerTube >= 6.1 *)
+      }
+    end
+  end
+  
   module Config = struct
-    type t = {
-      auto_blacklist : Jsont.json option;
-      avatar : Jsont.json option;
-      contact_form : Jsont.json option;
-      email : Jsont.json option;
-      export : Jsont.json option;
-      federation : Jsont.json option;
-      followings : Jsont.json option;
-      homepage : Jsont.json option;
-      import : Jsont.json option;
-      instance : Jsont.json option;
-      open_telemetry : Jsont.json option;  (** PeerTube >= 6.1 *)
-      plugin : Jsont.json option;
-      search : Jsont.json option;
-      server_commit : string option;
-      server_version : string option;
-      signup : Jsont.json option;
-      theme : Jsont.json option;
-      tracker : Jsont.json option;
-      transcoding : Jsont.json option;
-      trending : Jsont.json option;
-      user : Jsont.json option;
-      video : Jsont.json option;
-      video_caption : Jsont.json option;
-      views : Jsont.json option;  (** PeerTube >= 6.1 *)
-    }
+    include Types.Config
     
     let v ?auto_blacklist ?avatar ?contact_form ?email ?export ?federation ?followings ?homepage ?import ?instance ?open_telemetry ?plugin ?search ?server_commit ?server_version ?signup ?theme ?tracker ?transcoding ?trending ?user ?video ?video_caption ?views () = { auto_blacklist; avatar; contact_form; email; export; federation; followings; homepage; import; instance; open_telemetry; plugin; search; server_commit; server_version; signup; theme; tracker; transcoding; trending; user; video; video_caption; views }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Config.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module SendClientLog = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        level : Jsont.json;
+        message : string;
+        meta : string option;  (** Additional information regarding this log *)
+        stack_trace : string option;  (** Stack trace of the error if there is one *)
+        url : string;  (** URL of the current user page *)
+        user_agent : string option;  (** User agent of the web browser that sends the message *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      level : Jsont.json;
-      message : string;
-      meta : string option;  (** Additional information regarding this log *)
-      stack_trace : string option;  (** Stack trace of the error if there is one *)
-      url : string;  (** URL of the current user page *)
-      user_agent : string option;  (** User agent of the web browser that sends the message *)
-    }
+    include Types.T
     
     let v ~level ~message ~url ?meta ?stack_trace ?user_agent () = { level; message; meta; stack_trace; url; user_agent }
     
···
 end
 
 module RunnerRegistrationToken = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        id : int option;
+        registered_runners_count : int option;
+        registration_token : string option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      id : int option;
-      registered_runners_count : int option;
-      registration_token : string option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?created_at ?id ?registered_runners_count ?registration_token ?updated_at () = { created_at; id; registered_runners_count; registration_token; updated_at }
     
···
 end
 
 module RunnerJobState = struct
+  module Types = struct
+    module T = struct
+      (** The runner job state:
+        - `1` Pending
+        - `2` Processing
+        - `3` Completed
+        - `4` Errored
+        - `5` Waiting for a parent job
+        - `6` Cancelled
+        - `7` Parent had an error
+        - `8` Parent has been cancelled
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The runner job state:
-      - `1` Pending
-      - `2` Processing
-      - `3` Completed
-      - `4` Errored
-      - `5` Waiting for a parent job
-      - `6` Cancelled
-      - `7` Parent had an error
-      - `8` Parent has been cancelled
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module RunnerJobStateConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : RunnerJobState.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : RunnerJobState.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module RunnerJobPayload = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module RunnerJob = struct
+  module Types = struct
+    module Type = struct
+      type t = [
+        | `Vod_web_video_transcoding
+        | `Vod_hls_transcoding
+        | `Vod_audio_merge_transcoding
+        | `Live_rtmp_hls_transcoding
+      ]
+    end
+  
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        error : string option;  (** Error message if the job is errored *)
+        failures : int option;  (** Number of times a remote runner failed to process this job. After too many failures, the job in "error" state *)
+        finished_at : Ptime.t option;
+        parent : Jsont.json option;  (** If job has a parent job *)
+        payload : RunnerJobPayload.T.t option;
+        priority : int option;  (** Job priority (less has more priority) *)
+        progress : int option;  (** Percentage progress *)
+        runner : Jsont.json option;  (** If job is associated to a runner *)
+        started_at : Ptime.t option;
+        state : RunnerJobStateConstant.T.t option;
+        type_ : Type.t option;
+        updated_at : Ptime.t option;
+        uuid : Uuidv4.T.t option;
+      }
+    end
+  end
+  
   module Type = struct
-    type t = [
-      | `Vod_web_video_transcoding
-      | `Vod_hls_transcoding
-      | `Vod_audio_merge_transcoding
-      | `Live_rtmp_hls_transcoding
-    ]
+    include Types.Type
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"RunnerJobType"
···
   end
   
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      error : string option;  (** Error message if the job is errored *)
-      failures : int option;  (** Number of times a remote runner failed to process this job. After too many failures, the job in "error" state *)
-      finished_at : Ptime.t option;
-      parent : Jsont.json option;  (** If job has a parent job *)
-      payload : RunnerJobPayload.T.t option;
-      priority : int option;  (** Job priority (less has more priority) *)
-      progress : int option;  (** Percentage progress *)
-      runner : Jsont.json option;  (** If job is associated to a runner *)
-      started_at : Ptime.t option;
-      state : RunnerJobStateConstant.T.t option;
-      type_ : Type.t option;
-      updated_at : Ptime.t option;
-      uuid : Uuidv4.T.t option;
-    }
+    include Types.T
     
     let v ?created_at ?error ?failures ?finished_at ?parent ?payload ?priority ?progress ?runner ?started_at ?state ?type_ ?updated_at ?uuid () = { created_at; error; failures; finished_at; parent; payload; priority; progress; runner; started_at; state; type_; updated_at; uuid }
     
···
 end
 
 module RunnerJobAdmin = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        error : string option;  (** Error message if the job is errored *)
+        failures : int option;  (** Number of times a remote runner failed to process this job. After too many failures, the job in "error" state *)
+        finished_at : Ptime.t option;
+        parent : Jsont.json option;  (** If job has a parent job *)
+        payload : RunnerJobPayload.T.t option;
+        priority : int option;  (** Job priority (less has more priority) *)
+        progress : int option;  (** Percentage progress *)
+        runner : Jsont.json option;  (** If job is associated to a runner *)
+        started_at : Ptime.t option;
+        state : RunnerJobStateConstant.T.t option;
+        type_ : RunnerJob.Type.t option;
+        updated_at : Ptime.t option;
+        uuid : Uuidv4.T.t option;
+        private_payload : Jsont.json option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      error : string option;  (** Error message if the job is errored *)
-      failures : int option;  (** Number of times a remote runner failed to process this job. After too many failures, the job in "error" state *)
-      finished_at : Ptime.t option;
-      parent : Jsont.json option;  (** If job has a parent job *)
-      payload : RunnerJobPayload.T.t option;
-      priority : int option;  (** Job priority (less has more priority) *)
-      progress : int option;  (** Percentage progress *)
-      runner : Jsont.json option;  (** If job is associated to a runner *)
-      started_at : Ptime.t option;
-      state : RunnerJobStateConstant.T.t option;
-      type_ : RunnerJob.Type.t option;
-      updated_at : Ptime.t option;
-      uuid : Uuidv4.T.t option;
-      private_payload : Jsont.json option;
-    }
+    include Types.T
     
     let v ?created_at ?error ?failures ?finished_at ?parent ?payload ?priority ?progress ?runner ?started_at ?state ?type_ ?updated_at ?uuid ?private_payload () = { created_at; error; failures; finished_at; parent; payload; priority; progress; runner; started_at; state; type_; updated_at; uuid; private_payload }
     
···
 end
 
 module Runner = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        description : string option;
+        id : int option;
+        ip : string option;
+        last_contact : Ptime.t option;
+        name : string option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      description : string option;
-      id : int option;
-      ip : string option;
-      last_contact : Ptime.t option;
-      name : string option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?created_at ?description ?id ?ip ?last_contact ?name ?updated_at () = { created_at; description; id; ip; last_contact; name; updated_at }
     
···
 end
 
 module RequestTwoFactor = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        otp_request : Jsont.json option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      otp_request : Jsont.json option;
-    }
+    include Types.Response
     
     let v ?otp_request () = { otp_request }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module PredefinedAbuseReasons = struct
+  module Types = struct
+    module T = struct
+      (** Reason categories that help triage reports *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** Reason categories that help triage reports *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module Plugin = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        description : string option;
+        enabled : bool option;
+        homepage : string option;
+        latest_version : string option;
+        name : string option;
+        peertube_engine : string option;
+        settings : Jsont.json option;
+        type_ : int option;  (** - `1`: PLUGIN
+      - `2`: THEME
+       *)
+        uninstalled : bool option;
+        updated_at : Ptime.t option;
+        version : string option;
+      }
+    end
+  
+    module Response = struct
+      type t = {
+        data : T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      description : string option;
-      enabled : bool option;
-      homepage : string option;
-      latest_version : string option;
-      name : string option;
-      peertube_engine : string option;
-      settings : Jsont.json option;
-      type_ : int option;  (** - `1`: PLUGIN
-    - `2`: THEME
-     *)
-      uninstalled : bool option;
-      updated_at : Ptime.t option;
-      version : string option;
-    }
+    include Types.T
     
     let v ?created_at ?description ?enabled ?homepage ?latest_version ?name ?peertube_engine ?settings ?type_ ?uninstalled ?updated_at ?version () = { created_at; description; enabled; homepage; latest_version; name; peertube_engine; settings; type_; uninstalled; updated_at; version }
     
···
   end
   
   module Response = struct
-    type t = {
-      data : T.t list option;
-      total : int option;
-    }
+    include Types.Response
     
     let v ?data ?total () = { data; total }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"PluginResponse"
         (fun data total -> { data; total })
-      |> Jsont.Object.opt_mem "data" (Jsont.list T.jsont) ~enc:(fun r -> r.data)
+      |> Jsont.Object.opt_mem "data" (Openapi.Runtime.validated_list ~max_items:100 T.jsont) ~enc:(fun r -> r.data)
       |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available plugins 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get a plugin 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module PlayerThemeVideoSetting = struct
+  module Types = struct
+    module T = struct
+      (** Player theme setting for a video:
+        - `channel-default` Use the channel default theme
+        - `instance-default` Use the instance default theme
+        - `galaxy` Use the galaxy theme
+        - `lucide` Use the lucide theme
+       *)
+      type t = [
+        | `Channel_default
+        | `Instance_default
+        | `Galaxy
+        | `Lucide
+      ]
+    end
+  end
+  
   module T = struct
-    (** Player theme setting for a video:
-      - `channel-default` Use the channel default theme
-      - `instance-default` Use the instance default theme
-      - `galaxy` Use the galaxy theme
-      - `lucide` Use the lucide theme
-     *)
-    type t = [
-      | `Channel_default
-      | `Instance_default
-      | `Galaxy
-      | `Lucide
-    ]
+    include Types.T
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"PlayerThemeVideoSetting"
···
 end
 
 module PlayerVideoSettings = struct
+  module Types = struct
+    module Update = struct
+      (** Player settings update for a video *)
+      type t = {
+        theme : PlayerThemeVideoSetting.T.t;
+      }
+    end
+  
+    module T = struct
+      (** Player settings for a video *)
+      type t = {
+        theme : PlayerThemeVideoSetting.T.t option;
+      }
+    end
+  end
+  
   module Update = struct
-    (** Player settings update for a video *)
-    type t = {
-      theme : PlayerThemeVideoSetting.T.t;
-    }
+    include Types.Update
     
     let v ~theme () = { theme }
     
···
   end
   
   module T = struct
-    (** Player settings for a video *)
-    type t = {
-      theme : PlayerThemeVideoSetting.T.t option;
-    }
+    include Types.T
     
     let v ?theme () = { theme }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update video player settings
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module PlayerThemeChannelSetting = struct
+  module Types = struct
+    module T = struct
+      (** Player theme setting for a channel:
+        - `instance-default` Use the instance default theme
+        - `galaxy` Use the galaxy theme
+        - `lucide` Use the lucide theme
+       *)
+      type t = [
+        | `Instance_default
+        | `Galaxy
+        | `Lucide
+      ]
+    end
+  end
+  
   module T = struct
-    (** Player theme setting for a channel:
-      - `instance-default` Use the instance default theme
-      - `galaxy` Use the galaxy theme
-      - `lucide` Use the lucide theme
-     *)
-    type t = [
-      | `Instance_default
-      | `Galaxy
-      | `Lucide
-    ]
+    include Types.T
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"PlayerThemeChannelSetting"
···
 end
 
 module PlayerChannelSettings = struct
+  module Types = struct
+    module Update = struct
+      (** Player settings update for a channel *)
+      type t = {
+        theme : PlayerThemeChannelSetting.T.t;
+      }
+    end
+  
+    module T = struct
+      (** Player settings for a channel *)
+      type t = {
+        theme : PlayerThemeChannelSetting.T.t option;
+      }
+    end
+  end
+  
   module Update = struct
-    (** Player settings update for a channel *)
-    type t = {
-      theme : PlayerThemeChannelSetting.T.t;
-    }
+    include Types.Update
     
     let v ~theme () = { theme }
     
···
   end
   
   module T = struct
-    (** Player settings for a channel *)
-    type t = {
-      theme : PlayerThemeChannelSetting.T.t option;
-    }
+    include Types.T
     
     let v ?theme () = { theme }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update channel player settings
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module PlayerTheme = struct
+  module Types = struct
+    module T = struct
+      (** The player theme to use *)
+      type t = [
+        | `Galaxy
+        | `Lucide
+      ]
+    end
+  end
+  
   module T = struct
-    (** The player theme to use *)
-    type t = [
-      | `Galaxy
-      | `Lucide
-    ]
+    include Types.T
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"PlayerTheme"
···
 end
 
 module PlaybackMetric = struct
+  module Types = struct
+    module Create = struct
+      type t = {
+        buffer_stalled : float option;  (** How many times buffer has been stalled since the last metric creation *)
+        downloaded_bytes_http : float;  (** How many bytes were downloaded with HTTP since the last metric creation *)
+        downloaded_bytes_p2_p : float;  (** How many bytes were downloaded with P2P since the last metric creation *)
+        errors : float;  (** How many errors occurred since the last metric creation *)
+        fps : float option;  (** Current player video fps *)
+        p2p_enabled : bool;
+        p2p_peers : float option;  (** P2P peers connected (doesn't include WebSeed peers) *)
+        player_mode : string;
+        resolution : float option;  (** Current player video resolution *)
+        resolution_changes : float;  (** How many resolution changes occurred since the last metric creation *)
+        uploaded_bytes_p2_p : float;  (** How many bytes were uploaded with P2P since the last metric creation *)
+        video_id : Jsont.json;
+      }
+    end
+  end
+  
   module Create = struct
-    type t = {
-      buffer_stalled : float option;  (** How many times buffer has been stalled since the last metric creation *)
-      downloaded_bytes_http : float;  (** How many bytes were downloaded with HTTP since the last metric creation *)
-      downloaded_bytes_p2_p : float;  (** How many bytes were downloaded with P2P since the last metric creation *)
-      errors : float;  (** How many errors occurred since the last metric creation *)
-      fps : float option;  (** Current player video fps *)
-      p2p_enabled : bool;
-      p2p_peers : float option;  (** P2P peers connected (doesn't include WebSeed peers) *)
-      player_mode : string;
-      resolution : float option;  (** Current player video resolution *)
-      resolution_changes : float;  (** How many resolution changes occurred since the last metric creation *)
-      uploaded_bytes_p2_p : float;  (** How many bytes were uploaded with P2P since the last metric creation *)
-      video_id : Jsont.json;
-    }
+    include Types.Create
     
     let v ~downloaded_bytes_http ~downloaded_bytes_p2_p ~errors ~p2p_enabled ~player_mode ~resolution_changes ~uploaded_bytes_p2_p ~video_id ?buffer_stalled ?fps ?p2p_peers ?resolution () = { buffer_stalled; downloaded_bytes_http; downloaded_bytes_p2_p; errors; fps; p2p_enabled; p2p_peers; player_mode; resolution; resolution_changes; uploaded_bytes_p2_p; video_id }
     
···
 end
 
 module Password = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module UpdateUser = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        admin_flags : UserAdminFlags.T.t option;
+        email : Jsont.json option;  (** The updated email of the user *)
+        email_verified : bool option;  (** Set the email as verified *)
+        password : Password.T.t option;
+        plugin_auth : string option;  (** The auth plugin to use to authenticate the user *)
+        role : UserRole.T.t option;
+        video_quota : int option;  (** The updated video quota of the user in bytes *)
+        video_quota_daily : int option;  (** The updated daily video quota of the user in bytes *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      admin_flags : UserAdminFlags.T.t option;
-      email : Jsont.json option;  (** The updated email of the user *)
-      email_verified : bool option;  (** Set the email as verified *)
-      password : Password.T.t option;
-      plugin_auth : string option;  (** The auth plugin to use to authenticate the user *)
-      role : UserRole.T.t option;
-      video_quota : int option;  (** The updated video quota of the user in bytes *)
-      video_quota_daily : int option;  (** The updated daily video quota of the user in bytes *)
-    }
+    include Types.T
     
     let v ?admin_flags ?email ?email_verified ?password ?plugin_auth ?role ?video_quota ?video_quota_daily () = { admin_flags; email; email_verified; password; plugin_auth; role; video_quota; video_quota_daily }
     
···
 end
 
 module RegisterUser = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        channel : Jsont.json option;  (** channel base information used to create the first channel of the user *)
+        display_name : string option;  (** editable name of the user, displayed in its representations *)
+        email : string;  (** email of the user, used for login or service communications *)
+        password : Password.T.t;
+        username : Username.T.t;  (** immutable name of the user, used to find or mention its actor *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      channel : Jsont.json option;  (** channel base information used to create the first channel of the user *)
-      display_name : string option;  (** editable name of the user, displayed in its representations *)
-      email : string;  (** email of the user, used for login or service communications *)
-      password : Password.T.t;
-      username : Username.T.t;  (** immutable name of the user, used to find or mention its actor *)
-    }
+    include Types.T
     
     let v ~email ~password ~username ?channel ?display_name () = { channel; display_name; email; password; username }
     
···
       Jsont.Object.map ~kind:"RegisterUser"
         (fun channel display_name email password username -> { channel; display_name; email; password; username })
       |> Jsont.Object.opt_mem "channel" Jsont.json ~enc:(fun r -> r.channel)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:1 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
       |> Jsont.Object.mem "password" Password.T.jsont ~enc:(fun r -> r.password)
       |> Jsont.Object.mem "username" Username.T.jsont ~enc:(fun r -> r.username)
···
 end
 
 module OauthTokenPassword = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        client_id : string;
+        client_secret : string;
+        grant_type : string;
+        username : Jsont.json;
+        password : Password.T.t option;
+        external_auth_token : string option;  (** If you want to authenticate using an external authentication token you got from an auth plugin (like `peertube-plugin-auth-openid-connect` for example) instead of a password or a refresh token, provide it here. *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      client_id : string;
-      client_secret : string;
-      grant_type : string;
-      username : Jsont.json;
-      password : Password.T.t option;
-      external_auth_token : string option;  (** If you want to authenticate using an external authentication token you got from an auth plugin (like `peertube-plugin-auth-openid-connect` for example) instead of a password or a refresh token, provide it here. *)
-    }
+    include Types.T
     
     let v ~client_id ~client_secret ~grant_type ~username ?password ?external_auth_token () = { client_id; client_secret; grant_type; username; password; external_auth_token }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"OAuthToken-password"
         (fun client_id client_secret grant_type username password external_auth_token -> { client_id; client_secret; grant_type; username; password; external_auth_token })
-      |> Jsont.Object.mem "client_id" Jsont.string ~enc:(fun r -> r.client_id)
-      |> Jsont.Object.mem "client_secret" Jsont.string ~enc:(fun r -> r.client_secret)
+      |> Jsont.Object.mem "client_id" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_id)
+      |> Jsont.Object.mem "client_secret" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-zA-Z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_secret)
       |> Jsont.Object.mem "grant_type" Jsont.string ~enc:(fun r -> r.grant_type)
       |> Jsont.Object.mem "username" Jsont.json ~enc:(fun r -> r.username)
       |> Jsont.Object.opt_mem "password" Password.T.jsont ~enc:(fun r -> r.password)
···
 end
 
 module AddUser = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        user : Jsont.json option;
+      }
+    end
+  
+    module T = struct
+      type t = {
+        admin_flags : UserAdminFlags.T.t option;
+        channel_name : UsernameChannel.T.t option;
+        email : string;  (** The user email *)
+        password : Password.T.t;
+        role : UserRole.T.t;
+        username : Username.T.t;
+        video_quota : int option;  (** The user video quota in bytes *)
+        video_quota_daily : int option;  (** The user daily video quota in bytes *)
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      user : Jsont.json option;
-    }
+    include Types.Response
     
     let v ?user () = { user }
     
···
   end
   
   module T = struct
-    type t = {
-      admin_flags : UserAdminFlags.T.t option;
-      channel_name : UsernameChannel.T.t option;
-      email : string;  (** The user email *)
-      password : Password.T.t;
-      role : UserRole.T.t;
-      username : Username.T.t;
-      video_quota : int option;  (** The user video quota in bytes *)
-      video_quota_daily : int option;  (** The user daily video quota in bytes *)
-    }
+    include Types.T
     
     let v ~email ~password ~role ~username ?admin_flags ?channel_name ?video_quota ?video_quota_daily () = { admin_flags; channel_name; email; password; role; username; video_quota; video_quota_daily }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module OauthTokenRefreshToken = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        client_id : string;
+        client_secret : string;
+        grant_type : string;
+        refresh_token : string;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      client_id : string;
-      client_secret : string;
-      grant_type : string;
-      refresh_token : string;
-    }
+    include Types.T
     
     let v ~client_id ~client_secret ~grant_type ~refresh_token () = { client_id; client_secret; grant_type; refresh_token }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"OAuthToken-refresh_token"
         (fun client_id client_secret grant_type refresh_token -> { client_id; client_secret; grant_type; refresh_token })
-      |> Jsont.Object.mem "client_id" Jsont.string ~enc:(fun r -> r.client_id)
-      |> Jsont.Object.mem "client_secret" Jsont.string ~enc:(fun r -> r.client_secret)
+      |> Jsont.Object.mem "client_id" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_id)
+      |> Jsont.Object.mem "client_secret" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-zA-Z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_secret)
       |> Jsont.Object.mem "grant_type" Jsont.string ~enc:(fun r -> r.grant_type)
       |> Jsont.Object.mem "refresh_token" Jsont.string ~enc:(fun r -> r.refresh_token)
       |> Jsont.Object.skip_unknown
···
 end
 
 module OauthClient = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        client_id : string option;
+        client_secret : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      client_id : string option;
-      client_secret : string option;
-    }
+    include Types.T
     
     let v ?client_id ?client_secret () = { client_id; client_secret }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"OAuthClient"
         (fun client_id client_secret -> { client_id; client_secret })
-      |> Jsont.Object.opt_mem "client_id" Jsont.string ~enc:(fun r -> r.client_id)
-      |> Jsont.Object.opt_mem "client_secret" Jsont.string ~enc:(fun r -> r.client_secret)
+      |> Jsont.Object.opt_mem "client_id" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_id)
+      |> Jsont.Object.opt_mem "client_secret" (Openapi.Runtime.validated_string ~min_length:32 ~max_length:32 ~pattern:"/^[a-zA-Z0-9]$/" Jsont.string) ~enc:(fun r -> r.client_secret)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
   end
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module Nsfwpolicy = struct
+  module Types = struct
+    module T = struct
+      type t = [
+        | `Display
+        | `Warn
+        | `Do_not_list
+      ]
+    end
+  end
+  
   module T = struct
-    type t = [
-      | `Display
-      | `Warn
-      | `Do_not_list
-    ]
+    include Types.T
     
     let jsont : t Jsont.t =
       Jsont.map Jsont.string ~kind:"NSFWPolicy"
···
 end
 
 module Nsfwflag = struct
+  module Types = struct
+    module T = struct
+      (** 
+      NSFW flags (can be combined using bitwise or operator)
+      - `0` NONE
+      - `1` VIOLENT
+      - `2` EXPLICIT_SEX
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** 
-    NSFW flags (can be combined using bitwise or operator)
-    - `0` NONE
-    - `1` VIOLENT
-    - `2` EXPLICIT_SEX
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module UpdateMe = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        auto_play_next_video : bool option;  (** new preference regarding playing following videos automatically *)
+        auto_play_next_video_playlist : bool option;  (** new preference regarding playing following playlist videos automatically *)
+        auto_play_video : bool option;  (** new preference regarding playing videos automatically *)
+        current_password : Password.T.t option;
+        display_name : string option;  (** new name of the user in its representations *)
+        email : Jsont.json option;  (** new email used for login and service communications *)
+        language : string option;  (** default language for this user *)
+        no_account_setup_warning_modal : bool option;
+        no_instance_config_warning_modal : bool option;
+        no_welcome_modal : bool option;
+        nsfw_flags_blurred : Nsfwflag.T.t option;
+        nsfw_flags_displayed : Nsfwflag.T.t option;
+        nsfw_flags_hidden : Nsfwflag.T.t option;
+        nsfw_flags_warned : Nsfwflag.T.t option;
+        nsfw_policy : string option;  (** new NSFW display policy *)
+        p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
+        password : Password.T.t option;
+        theme : string option;
+        video_languages : string list option;  (** list of languages to filter videos down to *)
+        videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      auto_play_next_video : bool option;  (** new preference regarding playing following videos automatically *)
-      auto_play_next_video_playlist : bool option;  (** new preference regarding playing following playlist videos automatically *)
-      auto_play_video : bool option;  (** new preference regarding playing videos automatically *)
-      current_password : Password.T.t option;
-      display_name : string option;  (** new name of the user in its representations *)
-      email : Jsont.json option;  (** new email used for login and service communications *)
-      language : string option;  (** default language for this user *)
-      no_account_setup_warning_modal : bool option;
-      no_instance_config_warning_modal : bool option;
-      no_welcome_modal : bool option;
-      nsfw_flags_blurred : Nsfwflag.T.t option;
-      nsfw_flags_displayed : Nsfwflag.T.t option;
-      nsfw_flags_hidden : Nsfwflag.T.t option;
-      nsfw_flags_warned : Nsfwflag.T.t option;
-      nsfw_policy : string option;  (** new NSFW display policy *)
-      p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
-      password : Password.T.t option;
-      theme : string option;
-      video_languages : string list option;  (** list of languages to filter videos down to *)
-      videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
-    }
+    include Types.T
     
     let v ?auto_play_next_video ?auto_play_next_video_playlist ?auto_play_video ?current_password ?display_name ?email ?language ?no_account_setup_warning_modal ?no_instance_config_warning_modal ?no_welcome_modal ?nsfw_flags_blurred ?nsfw_flags_displayed ?nsfw_flags_hidden ?nsfw_flags_warned ?nsfw_policy ?p2p_enabled ?password ?theme ?video_languages ?videos_history_enabled () = { auto_play_next_video; auto_play_next_video_playlist; auto_play_video; current_password; display_name; email; language; no_account_setup_warning_modal; no_instance_config_warning_modal; no_welcome_modal; nsfw_flags_blurred; nsfw_flags_displayed; nsfw_flags_hidden; nsfw_flags_warned; nsfw_policy; p2p_enabled; password; theme; video_languages; videos_history_enabled }
     
···
       |> Jsont.Object.opt_mem "autoPlayNextVideoPlaylist" Jsont.bool ~enc:(fun r -> r.auto_play_next_video_playlist)
       |> Jsont.Object.opt_mem "autoPlayVideo" Jsont.bool ~enc:(fun r -> r.auto_play_video)
       |> Jsont.Object.opt_mem "currentPassword" Password.T.jsont ~enc:(fun r -> r.current_password)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.opt_mem "email" Jsont.json ~enc:(fun r -> r.email)
       |> Jsont.Object.opt_mem "language" Jsont.string ~enc:(fun r -> r.language)
       |> Jsont.Object.opt_mem "noAccountSetupWarningModal" Jsont.bool ~enc:(fun r -> r.no_account_setup_warning_modal)
···
 end
 
 module NotificationSettingValue = struct
+  module Types = struct
+    module T = struct
+      (** Notification type. One of the following values, or a sum of multiple values:
+      - `0` NONE
+      - `1` WEB
+      - `2` EMAIL
+       *)
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    (** Notification type. One of the following values, or a sum of multiple values:
-    - `0` NONE
-    - `1` WEB
-    - `2` EMAIL
-     *)
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module UserNotificationSettings = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        abuse_as_moderator : NotificationSettingValue.T.t option;
+        abuse_new_message : NotificationSettingValue.T.t option;
+        abuse_state_change : NotificationSettingValue.T.t option;
+        auto_instance_following : NotificationSettingValue.T.t option;
+        blacklist_on_my_video : NotificationSettingValue.T.t option;
+        comment_mention : NotificationSettingValue.T.t option;
+        my_video_import_finished : NotificationSettingValue.T.t option;
+        my_video_published : NotificationSettingValue.T.t option;
+        my_video_studio_edition_finished : NotificationSettingValue.T.t option;
+        my_video_transcription_generated : NotificationSettingValue.T.t option;
+        new_comment_on_my_video : NotificationSettingValue.T.t option;
+        new_follow : NotificationSettingValue.T.t option;
+        new_instance_follower : NotificationSettingValue.T.t option;
+        new_peer_tube_version : NotificationSettingValue.T.t option;
+        new_plugin_version : NotificationSettingValue.T.t option;
+        new_user_registration : NotificationSettingValue.T.t option;
+        new_video_from_subscription : NotificationSettingValue.T.t option;
+        video_auto_blacklist_as_moderator : NotificationSettingValue.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      abuse_as_moderator : NotificationSettingValue.T.t option;
-      abuse_new_message : NotificationSettingValue.T.t option;
-      abuse_state_change : NotificationSettingValue.T.t option;
-      auto_instance_following : NotificationSettingValue.T.t option;
-      blacklist_on_my_video : NotificationSettingValue.T.t option;
-      comment_mention : NotificationSettingValue.T.t option;
-      my_video_import_finished : NotificationSettingValue.T.t option;
-      my_video_published : NotificationSettingValue.T.t option;
-      my_video_studio_edition_finished : NotificationSettingValue.T.t option;
-      my_video_transcription_generated : NotificationSettingValue.T.t option;
-      new_comment_on_my_video : NotificationSettingValue.T.t option;
-      new_follow : NotificationSettingValue.T.t option;
-      new_instance_follower : NotificationSettingValue.T.t option;
-      new_peer_tube_version : NotificationSettingValue.T.t option;
-      new_plugin_version : NotificationSettingValue.T.t option;
-      new_user_registration : NotificationSettingValue.T.t option;
-      new_video_from_subscription : NotificationSettingValue.T.t option;
-      video_auto_blacklist_as_moderator : NotificationSettingValue.T.t option;
-    }
+    include Types.T
     
     let v ?abuse_as_moderator ?abuse_new_message ?abuse_state_change ?auto_instance_following ?blacklist_on_my_video ?comment_mention ?my_video_import_finished ?my_video_published ?my_video_studio_edition_finished ?my_video_transcription_generated ?new_comment_on_my_video ?new_follow ?new_instance_follower ?new_peer_tube_version ?new_plugin_version ?new_user_registration ?new_video_from_subscription ?video_auto_blacklist_as_moderator () = { abuse_as_moderator; abuse_new_message; abuse_state_change; auto_instance_following; blacklist_on_my_video; comment_mention; my_video_import_finished; my_video_published; my_video_studio_edition_finished; my_video_transcription_generated; new_comment_on_my_video; new_follow; new_instance_follower; new_peer_tube_version; new_plugin_version; new_user_registration; new_video_from_subscription; video_auto_blacklist_as_moderator }
     
···
 end
 
 module NewFeatureInfo = struct
+  module Types = struct
+    module Type = struct
+      (** Represent a new feature that can be displayed to inform users. One of the following values:
+      
+        - `1` CHANNEL_COLLABORATION
+       *)
+      type t = string
+    end
+  end
+  
   module Type = struct
-    (** Represent a new feature that can be displayed to inform users. One of the following values:
-    
-      - `1` CHANNEL_COLLABORATION
-     *)
-    type t = string
-    
+    include Types.Type
     let jsont = Jsont.string
   end
 end
 
 module MrsspeerLink = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        href : string option;
+        type_ : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      href : string option;
-      type_ : string option;
-    }
+    include Types.T
     
     let v ?href ?type_ () = { href; type_ }
     
···
 end
 
 module MrssgroupContent = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        duration : int option;
+        file_size : int option;
+        framerate : int option;
+        height : int option;
+        lang : string option;
+        type_ : string option;
+        url : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      duration : int option;
-      file_size : int option;
-      framerate : int option;
-      height : int option;
-      lang : string option;
-      type_ : string option;
-      url : string option;
-    }
+    include Types.T
     
     let v ?duration ?file_size ?framerate ?height ?lang ?type_ ?url () = { duration; file_size; framerate; height; lang; type_; url }
     
···
 end
 
 module LiveVideoSession = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        end_date : Ptime.t option;  (** End date of the live session *)
+        error : int option;  (** Error type if an error occurred during the live session:
+        - `1`: Bad socket health (transcoding is too slow)
+        - `2`: Max duration exceeded
+        - `3`: Quota exceeded
+        - `4`: Quota FFmpeg error
+        - `5`: Video has been blacklisted during the live
+       *)
+        id : int option;
+        replay_video : Jsont.json option;  (** Video replay information *)
+        start_date : Ptime.t option;  (** Start date of the live session *)
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      end_date : Ptime.t option;  (** End date of the live session *)
-      error : int option;  (** Error type if an error occurred during the live session:
-      - `1`: Bad socket health (transcoding is too slow)
-      - `2`: Max duration exceeded
-      - `3`: Quota exceeded
-      - `4`: Quota FFmpeg error
-      - `5`: Video has been blacklisted during the live
-     *)
-      id : int option;
-      replay_video : Jsont.json option;  (** Video replay information *)
-      start_date : Ptime.t option;  (** Start date of the live session *)
-    }
+    include Types.Response
     
     let v ?end_date ?error ?id ?replay_video ?start_date () = { end_date; error; id; replay_video; start_date }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module LiveVideoLatencyMode = struct
+  module Types = struct
+    module T = struct
+      (** The live latency mode (Default = `1`, High latency = `2`, Small Latency = `3`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The live latency mode (Default = `1`, High latency = `2`, Small Latency = `3`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module LiveSchedule = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        start_at : Ptime.t option;  (** Date when the stream is scheduled to air at *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      start_at : Ptime.t option;  (** Date when the stream is scheduled to air at *)
-    }
+    include Types.T
     
     let v ?start_at () = { start_at }
     
···
 end
 
 module LiveVideo = struct
+  module Types = struct
+    module Update = struct
+      type t = {
+        latency_mode : LiveVideoLatencyMode.T.t option;  (** User can select live latency mode if enabled by the instance *)
+        permanent_live : bool option;  (** User can stream multiple times in a permanent live *)
+        replay_settings : LiveVideoReplaySettings.T.t option;
+        save_replay : bool option;
+        schedules : LiveSchedule.T.t list option;
+      }
+    end
+  
+    module Response = struct
+      type t = {
+        latency_mode : LiveVideoLatencyMode.T.t option;  (** User can select live latency mode if enabled by the instance *)
+        permanent_live : bool option;  (** User can stream multiple times in a permanent live *)
+        replay_settings : LiveVideoReplaySettings.T.t option;
+        rtmp_url : string option;  (** Included in the response if an appropriate token is provided *)
+        rtmps_url : string option;  (** Included in the response if an appropriate token is provided *)
+        save_replay : bool option;
+        schedules : LiveSchedule.T.t list option;
+        stream_key : string option;  (** RTMP stream key to use to stream into this live video. Included in the response if an appropriate token is provided *)
+      }
+    end
+  end
+  
   module Update = struct
-    type t = {
-      latency_mode : LiveVideoLatencyMode.T.t option;  (** User can select live latency mode if enabled by the instance *)
-      permanent_live : bool option;  (** User can stream multiple times in a permanent live *)
-      replay_settings : LiveVideoReplaySettings.T.t option;
-      save_replay : bool option;
-      schedules : LiveSchedule.T.t list option;
-    }
+    include Types.Update
     
     let v ?latency_mode ?permanent_live ?replay_settings ?save_replay ?schedules () = { latency_mode; permanent_live; replay_settings; save_replay; schedules }
     
···
   end
   
   module Response = struct
-    type t = {
-      latency_mode : LiveVideoLatencyMode.T.t option;  (** User can select live latency mode if enabled by the instance *)
-      permanent_live : bool option;  (** User can stream multiple times in a permanent live *)
-      replay_settings : LiveVideoReplaySettings.T.t option;
-      rtmp_url : string option;  (** Included in the response if an appropriate token is provided *)
-      rtmps_url : string option;  (** Included in the response if an appropriate token is provided *)
-      save_replay : bool option;
-      schedules : LiveSchedule.T.t list option;
-      stream_key : string option;  (** RTMP stream key to use to stream into this live video. Included in the response if an appropriate token is provided *)
-    }
+    include Types.Response
     
     let v ?latency_mode ?permanent_live ?replay_settings ?rtmp_url ?rtmps_url ?save_replay ?schedules ?stream_key () = { latency_mode; permanent_live; replay_settings; rtmp_url; rtmps_url; save_replay; schedules; stream_key }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module ImportVideosInChannel = struct
+  module Types = struct
+    module Create = struct
+      type t = {
+        external_channel_url : string;
+        video_channel_sync_id : int option;  (** If part of a channel sync process, specify its id to assign video imports to this channel synchronization *)
+      }
+    end
+  end
+  
   module Create = struct
-    type t = {
-      external_channel_url : string;
-      video_channel_sync_id : int option;  (** If part of a channel sync process, specify its id to assign video imports to this channel synchronization *)
-    }
+    include Types.Create
     
     let v ~external_channel_url ?video_channel_sync_id () = { external_channel_url; video_channel_sync_id }
     
···
 end
 
 module Id = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module WatchedWordsLists = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        id : Id.T.t option;
+        list_name : string option;
+        updated_at : Ptime.t option;
+        words : string list option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      id : Id.T.t option;
-      list_name : string option;
-      updated_at : Ptime.t option;
-      words : string list option;
-    }
+    include Types.T
     
     let v ?created_at ?id ?list_name ?updated_at ?words () = { created_at; id; list_name; updated_at; words }
     
···
 end
 
 module VideoRedundancy = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : Id.T.t option;
+        name : string option;
+        redundancies : Jsont.json option;
+        url : string option;
+        uuid : Uuidv4.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : Id.T.t option;
-      name : string option;
-      redundancies : Jsont.json option;
-      url : string option;
-      uuid : Uuidv4.T.t option;
-    }
+    include Types.T
     
     let v ?id ?name ?redundancies ?url ?uuid () = { id; name; redundancies; url; uuid }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoPassword = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : Id.T.t option;
+        password : string option;
+        video_id : Id.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : Id.T.t option;
-      password : string option;
-      video_id : Id.T.t option;
-    }
+    include Types.T
     
     let v ?id ?password ?video_id () = { id; password; video_id }
     
···
       Jsont.Object.map ~kind:"VideoPassword"
         (fun id password video_id -> { id; password; video_id })
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
-      |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
+      |> Jsont.Object.opt_mem "password" (Openapi.Runtime.validated_string ~min_length:2 Jsont.string) ~enc:(fun r -> r.password)
       |> Jsont.Object.opt_mem "videoId" Id.T.jsont ~enc:(fun r -> r.video_id)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
···
 end
 
 module VideoPasswordList = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : VideoPassword.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : VideoPassword.T.t list option;
-      total : int option;
-    }
+    include Types.T
     
     let v ?data ?total () = { data; total }
     
···
 end
 
 module VideoBlacklist = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        description : string option;
+        dislikes : int option;
+        duration : int option;
+        id : Id.T.t option;
+        likes : int option;
+        name : string option;
+        nsfw : bool option;
+        updated_at : Ptime.t option;
+        uuid : Uuidv4.T.t option;
+        video_id : Jsont.json option;
+        views : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      description : string option;
-      dislikes : int option;
-      duration : int option;
-      id : Id.T.t option;
-      likes : int option;
-      name : string option;
-      nsfw : bool option;
-      updated_at : Ptime.t option;
-      uuid : Uuidv4.T.t option;
-      video_id : Jsont.json option;
-      views : int option;
-    }
+    include Types.T
     
     let v ?created_at ?description ?dislikes ?duration ?id ?likes ?name ?nsfw ?updated_at ?uuid ?video_id ?views () = { created_at; description; dislikes; duration; id; likes; name; nsfw; updated_at; uuid; video_id; views }
     
···
       Jsont.Object.map ~kind:"VideoBlacklist"
         (fun created_at description dislikes duration id likes name nsfw updated_at uuid video_id views -> { created_at; description; dislikes; duration; id; likes; name; nsfw; updated_at; uuid; video_id; views })
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
-      |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
+      |> Jsont.Object.opt_mem "description" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:10000 Jsont.string) ~enc:(fun r -> r.description)
       |> Jsont.Object.opt_mem "dislikes" Jsont.int ~enc:(fun r -> r.dislikes)
       |> Jsont.Object.opt_mem "duration" Jsont.int ~enc:(fun r -> r.duration)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
       |> Jsont.Object.opt_mem "likes" Jsont.int ~enc:(fun r -> r.likes)
-      |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.opt_mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
       |> Jsont.Object.opt_mem "uuid" Uuidv4.T.jsont ~enc:(fun r -> r.uuid)
···
 end
 
 module UserRegistration = struct
+  module Types = struct
+    module Request = struct
+      type t = {
+        channel : Jsont.json option;  (** channel base information used to create the first channel of the user *)
+        display_name : string option;  (** editable name of the user, displayed in its representations *)
+        email : string;  (** email of the user, used for login or service communications *)
+        password : Password.T.t;
+        username : Username.T.t;  (** immutable name of the user, used to find or mention its actor *)
+        registration_reason : string;  (** reason for the user to register on the instance *)
+      }
+    end
+  
+    module T = struct
+      type t = {
+        account_display_name : string option;
+        channel_display_name : string option;
+        channel_handle : string option;
+        created_at : Ptime.t option;
+        email : string option;
+        email_verified : bool option;
+        id : Id.T.t option;
+        moderation_response : string option;
+        registration_reason : string option;
+        state : Jsont.json option;
+        updated_at : Ptime.t option;
+        user : Jsont.json option;  (** If the registration has been accepted, this is a partial user object created by the registration *)
+        username : string option;
+      }
+    end
+  end
+  
   module Request = struct
-    type t = {
-      channel : Jsont.json option;  (** channel base information used to create the first channel of the user *)
-      display_name : string option;  (** editable name of the user, displayed in its representations *)
-      email : string;  (** email of the user, used for login or service communications *)
-      password : Password.T.t;
-      username : Username.T.t;  (** immutable name of the user, used to find or mention its actor *)
-      registration_reason : string;  (** reason for the user to register on the instance *)
-    }
+    include Types.Request
     
     let v ~email ~password ~username ~registration_reason ?channel ?display_name () = { channel; display_name; email; password; username; registration_reason }
     
···
       Jsont.Object.map ~kind:"UserRegistrationRequest"
         (fun channel display_name email password username registration_reason -> { channel; display_name; email; password; username; registration_reason })
       |> Jsont.Object.opt_mem "channel" Jsont.json ~enc:(fun r -> r.channel)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:1 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
       |> Jsont.Object.mem "password" Password.T.jsont ~enc:(fun r -> r.password)
       |> Jsont.Object.mem "username" Username.T.jsont ~enc:(fun r -> r.username)
···
   end
   
   module T = struct
-    type t = {
-      account_display_name : string option;
-      channel_display_name : string option;
-      channel_handle : string option;
-      created_at : Ptime.t option;
-      email : string option;
-      email_verified : bool option;
-      id : Id.T.t option;
-      moderation_response : string option;
-      registration_reason : string option;
-      state : Jsont.json option;
-      updated_at : Ptime.t option;
-      user : Jsont.json option;  (** If the registration has been accepted, this is a partial user object created by the registration *)
-      username : string option;
-    }
+    include Types.T
     
     let v ?account_display_name ?channel_display_name ?channel_handle ?created_at ?email ?email_verified ?id ?moderation_response ?registration_reason ?state ?updated_at ?user ?username () = { account_display_name; channel_display_name; channel_handle; created_at; email; email_verified; id; moderation_response; registration_reason; state; updated_at; user; username }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module Job = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        data : Jsont.json option;
+        error : Jsont.json option;
+        finished_on : Ptime.t option;
+        id : Id.T.t option;
+        processed_on : Ptime.t option;
+        state : string option;
+        type_ : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      data : Jsont.json option;
-      error : Jsont.json option;
-      finished_on : Ptime.t option;
-      id : Id.T.t option;
-      processed_on : Ptime.t option;
-      state : string option;
-      type_ : string option;
-    }
+    include Types.T
     
     let v ?created_at ?data ?error ?finished_on ?id ?processed_on ?state ?type_ () = { created_at; data; error; finished_on; id; processed_on; state; type_ }
     
···
 end
 
 module GetMeVideoRating = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : Id.T.t;
+        rating : string;  (** Rating of the video *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : Id.T.t;
-      rating : string;  (** Rating of the video *)
-    }
+    include Types.T
     
     let v ~id ~rating () = { id; rating }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module FileRedundancyInformation = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        expires_on : Ptime.t option;
+        file_url : string option;
+        id : Id.T.t option;
+        size : int option;
+        strategy : string option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      expires_on : Ptime.t option;
-      file_url : string option;
-      id : Id.T.t option;
-      size : int option;
-      strategy : string option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?created_at ?expires_on ?file_url ?id ?size ?strategy ?updated_at () = { created_at; expires_on; file_url; id; size; strategy; updated_at }
     
···
 end
 
 module FileStorage = struct
+  module Types = struct
+    module T = struct
+      (** The file storage type:
+        - `0` File system
+        - `1` Object storage
+       *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The file storage type:
-      - `0` File system
-      - `1` Object storage
-     *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module VideoFile = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        file_download_url : string option;  (** URL endpoint that transfers the video file as an attachment (so that the browser opens a download dialog) *)
+        file_url : string option;  (** Direct URL of the video *)
+        fps : float option;  (** Frames per second of the video file *)
+        has_audio : bool option;  (** **PeerTube >= 6.2** The file container has an audio stream *)
+        has_video : bool option;  (** **PeerTube >= 6.2** The file container has a video stream *)
+        height : float option;  (** **PeerTube >= 6.1** Video stream height *)
+        id : Id.T.t option;
+        magnet_uri : string option;  (** magnet URI allowing to resolve the video via BitTorrent without a metainfo file *)
+        metadata_url : string option;  (** URL dereferencing the output of ffprobe on the file *)
+        playlist_url : string option;  (** Playlist URL of the file if it is owned by a playlist *)
+        resolution : VideoResolutionConstant.T.t option;
+        size : int option;  (** Video file size in bytes *)
+        storage : FileStorage.T.t option;
+        torrent_download_url : string option;  (** URL endpoint that transfers the torrent file as an attachment (so that the browser opens a download dialog) *)
+        torrent_url : string option;  (** Direct URL of the torrent file *)
+        width : float option;  (** **PeerTube >= 6.1** Video stream width *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      file_download_url : string option;  (** URL endpoint that transfers the video file as an attachment (so that the browser opens a download dialog) *)
-      file_url : string option;  (** Direct URL of the video *)
-      fps : float option;  (** Frames per second of the video file *)
-      has_audio : bool option;  (** **PeerTube >= 6.2** The file container has an audio stream *)
-      has_video : bool option;  (** **PeerTube >= 6.2** The file container has a video stream *)
-      height : float option;  (** **PeerTube >= 6.1** Video stream height *)
-      id : Id.T.t option;
-      magnet_uri : string option;  (** magnet URI allowing to resolve the video via BitTorrent without a metainfo file *)
-      metadata_url : string option;  (** URL dereferencing the output of ffprobe on the file *)
-      playlist_url : string option;  (** Playlist URL of the file if it is owned by a playlist *)
-      resolution : VideoResolutionConstant.T.t option;
-      size : int option;  (** Video file size in bytes *)
-      storage : FileStorage.T.t option;
-      torrent_download_url : string option;  (** URL endpoint that transfers the torrent file as an attachment (so that the browser opens a download dialog) *)
-      torrent_url : string option;  (** Direct URL of the torrent file *)
-      width : float option;  (** **PeerTube >= 6.1** Video stream width *)
-    }
+    include Types.T
     
     let v ?file_download_url ?file_url ?fps ?has_audio ?has_video ?height ?id ?magnet_uri ?metadata_url ?playlist_url ?resolution ?size ?storage ?torrent_download_url ?torrent_url ?width () = { file_download_url; file_url; fps; has_audio; has_video; height; id; magnet_uri; metadata_url; playlist_url; resolution; size; storage; torrent_download_url; torrent_url; width }
     
···
       |> Jsont.Object.opt_mem "hasVideo" Jsont.bool ~enc:(fun r -> r.has_video)
       |> Jsont.Object.opt_mem "height" Jsont.number ~enc:(fun r -> r.height)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
-      |> Jsont.Object.opt_mem "magnetUri" Jsont.string ~enc:(fun r -> r.magnet_uri)
+      |> Jsont.Object.opt_mem "magnetUri" (Openapi.Runtime.validated_string ~pattern:"/magnet:\\?xt=urn:[a-z0-9]+:[a-z0-9]{32}/i" Jsont.string) ~enc:(fun r -> r.magnet_uri)
       |> Jsont.Object.opt_mem "metadataUrl" Jsont.string ~enc:(fun r -> r.metadata_url)
       |> Jsont.Object.opt_mem "playlistUrl" Jsont.string ~enc:(fun r -> r.playlist_url)
       |> Jsont.Object.opt_mem "resolution" VideoResolutionConstant.T.jsont ~enc:(fun r -> r.resolution)
···
 end
 
 module VideoStreamingPlaylistsHls = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        files : VideoFile.T.t list option;  (** Video files associated to this playlist.
+      
+      The difference with the root `files` property is that these files are fragmented, so they can be used in this streaming playlist (HLS, etc.)
+       *)
+        playlist_url : string option;
+        redundancies : Jsont.json list option;
+        segments_sha256_url : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      files : VideoFile.T.t list option;  (** Video files associated to this playlist.
-    
-    The difference with the root `files` property is that these files are fragmented, so they can be used in this streaming playlist (HLS, etc.)
-     *)
-      playlist_url : string option;
-      redundancies : Jsont.json list option;
-      segments_sha256_url : string option;
-    }
+    include Types.T
     
     let v ?files ?playlist_url ?redundancies ?segments_sha256_url () = { files; playlist_url; redundancies; segments_sha256_url }
     
···
 end
 
 module VideoStreamingPlaylists = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : Id.T.t option;
+        type_ : int option;  (** Playlist type:
+      - `1`: HLS
+       *)
+        files : VideoFile.T.t list option;  (** Video files associated to this playlist.
+      
+      The difference with the root `files` property is that these files are fragmented, so they can be used in this streaming playlist (HLS, etc.)
+       *)
+        playlist_url : string option;
+        redundancies : Jsont.json list option;
+        segments_sha256_url : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : Id.T.t option;
-      type_ : int option;  (** Playlist type:
-    - `1`: HLS
-     *)
-      files : VideoFile.T.t list option;  (** Video files associated to this playlist.
-    
-    The difference with the root `files` property is that these files are fragmented, so they can be used in this streaming playlist (HLS, etc.)
-     *)
-      playlist_url : string option;
-      redundancies : Jsont.json list option;
-      segments_sha256_url : string option;
-    }
+    include Types.T
     
     let v ?id ?type_ ?files ?playlist_url ?redundancies ?segments_sha256_url () = { id; type_; files; playlist_url; redundancies; segments_sha256_url }
     
···
 end
 
 module CustomHomepage = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        content : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      content : string option;
-    }
+    include Types.T
     
     let v ?content () = { content }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module CommentAutoTagPolicies = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        review : string list option;  (** Auto tags that automatically set the comment in review state *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      review : string list option;  (** Auto tags that automatically set the comment in review state *)
-    }
+    include Types.T
     
     let v ?review () = { review }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module ChannelActivityList = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        data : Jsont.json list option;
+        total : int option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      data : Jsont.json list option;
-      total : int option;
-    }
+    include Types.Response
     
     let v ?data ?total () = { data; total }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module Block = struct
+  module Types = struct
+    module Status = struct
+      type t = {
+        accounts : Jsont.json option;
+        hosts : Jsont.json option;
+      }
+    end
+  end
+  
   module Status = struct
-    type t = {
-      accounts : Jsont.json option;
-      hosts : Jsont.json option;
-    }
+    include Types.Status
     
     let v ?accounts ?hosts () = { accounts; hosts }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Status.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module AutomaticTagAvailable = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        available : Jsont.json list option;  (** Available auto tags that can be used to filter objects or set a comment in review state *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      available : Jsont.json list option;  (** Available auto tags that can be used to filter objects or set a comment in review state *)
-    }
+    include Types.T
     
     let v ?available () = { available }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get server available auto tags
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module AddVideoPasswords = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module VideoUploadRequestResumable = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        category : VideoCategorySet.T.t option;
+        channel_id : int;  (** Channel id that will contain this video *)
+        comments_policy : VideoCommentsPolicySet.T.t option;
+        description : string option;  (** Video description *)
+        download_enabled : bool option;  (** Enable or disable downloading for this video *)
+        generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
+        language : VideoLanguageSet.T.t option;
+        licence : VideoLicenceSet.T.t option;
+        name : string;  (** Video name *)
+        nsfw : bool option;  (** Whether or not this video contains sensitive content *)
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
+        privacy : VideoPrivacySet.T.t option;
+        schedule_update : VideoScheduled.Update.t option;
+        support : string option;  (** A text tell the audience how to support the video creator *)
+        tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
+        video_passwords : AddVideoPasswords.T.t option;
+        wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
+        filename : string;  (** Video filename including extension *)
+        thumbnailfile : string option;  (** Video thumbnail file *)
+        previewfile : string option;  (** Video preview file *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      category : VideoCategorySet.T.t option;
-      channel_id : int;  (** Channel id that will contain this video *)
-      comments_policy : VideoCommentsPolicySet.T.t option;
-      description : string option;  (** Video description *)
-      download_enabled : bool option;  (** Enable or disable downloading for this video *)
-      generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
-      language : VideoLanguageSet.T.t option;
-      licence : VideoLicenceSet.T.t option;
-      name : string;  (** Video name *)
-      nsfw : bool option;  (** Whether or not this video contains sensitive content *)
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
-      privacy : VideoPrivacySet.T.t option;
-      schedule_update : VideoScheduled.Update.t option;
-      support : string option;  (** A text tell the audience how to support the video creator *)
-      tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
-      video_passwords : AddVideoPasswords.T.t option;
-      wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
-      filename : string;  (** Video filename including extension *)
-      thumbnailfile : string option;  (** Video thumbnail file *)
-      previewfile : string option;  (** Video preview file *)
-    }
+    include Types.T
     
     let v ~channel_id ~name ~filename ?category ?comments_policy ?description ?download_enabled ?generate_transcription ?language ?licence ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?privacy ?schedule_update ?support ?tags ?video_passwords ?wait_transcoding ?thumbnailfile ?previewfile () = { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; privacy; schedule_update; support; tags; video_passwords; wait_transcoding; filename; thumbnailfile; previewfile }
     
···
       Jsont.Object.map ~kind:"VideoUploadRequestResumable"
         (fun category channel_id comments_policy description download_enabled generate_transcription language licence name nsfw nsfw_flags nsfw_summary originally_published_at privacy schedule_update support tags video_passwords wait_transcoding filename thumbnailfile previewfile -> { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; privacy; schedule_update; support; tags; video_passwords; wait_transcoding; filename; thumbnailfile; previewfile })
       |> Jsont.Object.opt_mem "category" VideoCategorySet.T.jsont ~enc:(fun r -> r.category)
-      |> Jsont.Object.mem "channelId" Jsont.int ~enc:(fun r -> r.channel_id)
+      |> Jsont.Object.mem "channelId" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.channel_id)
       |> Jsont.Object.opt_mem "commentsPolicy" VideoCommentsPolicySet.T.jsont ~enc:(fun r -> r.comments_policy)
       |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
       |> Jsont.Object.opt_mem "downloadEnabled" Jsont.bool ~enc:(fun r -> r.download_enabled)
       |> Jsont.Object.opt_mem "generateTranscription" Jsont.bool ~enc:(fun r -> r.generate_transcription)
       |> Jsont.Object.opt_mem "language" VideoLanguageSet.T.jsont ~enc:(fun r -> r.language)
       |> Jsont.Object.opt_mem "licence" VideoLicenceSet.T.jsont ~enc:(fun r -> r.licence)
-      |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.json ~enc:(fun r -> r.nsfw_summary)
···
       |> Jsont.Object.opt_mem "privacy" VideoPrivacySet.T.jsont ~enc:(fun r -> r.privacy)
       |> Jsont.Object.opt_mem "scheduleUpdate" VideoScheduled.Update.jsont ~enc:(fun r -> r.schedule_update)
       |> Jsont.Object.opt_mem "support" Jsont.string ~enc:(fun r -> r.support)
-      |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+      |> Jsont.Object.opt_mem "tags" (Openapi.Runtime.validated_list ~min_items:1 ~max_items:5 ~unique_items:true Jsont.string) ~enc:(fun r -> r.tags)
       |> Jsont.Object.opt_mem "videoPasswords" AddVideoPasswords.T.jsont ~enc:(fun r -> r.video_passwords)
       |> Jsont.Object.opt_mem "waitTranscoding" Jsont.bool ~enc:(fun r -> r.wait_transcoding)
       |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
···
 end
 
 module VideoUploadRequestLegacy = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        category : VideoCategorySet.T.t option;
+        channel_id : int;  (** Channel id that will contain this video *)
+        comments_policy : VideoCommentsPolicySet.T.t option;
+        description : string option;  (** Video description *)
+        download_enabled : bool option;  (** Enable or disable downloading for this video *)
+        generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
+        language : VideoLanguageSet.T.t option;
+        licence : VideoLicenceSet.T.t option;
+        name : string;  (** Video name *)
+        nsfw : bool option;  (** Whether or not this video contains sensitive content *)
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
+        previewfile : string option;  (** Video preview file *)
+        privacy : VideoPrivacySet.T.t option;
+        schedule_update : VideoScheduled.Update.t option;
+        support : string option;  (** A text tell the audience how to support the video creator *)
+        tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
+        thumbnailfile : string option;  (** Video thumbnail file *)
+        video_passwords : AddVideoPasswords.T.t option;
+        wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
+        videofile : string;  (** Video file *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      category : VideoCategorySet.T.t option;
-      channel_id : int;  (** Channel id that will contain this video *)
-      comments_policy : VideoCommentsPolicySet.T.t option;
-      description : string option;  (** Video description *)
-      download_enabled : bool option;  (** Enable or disable downloading for this video *)
-      generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
-      language : VideoLanguageSet.T.t option;
-      licence : VideoLicenceSet.T.t option;
-      name : string;  (** Video name *)
-      nsfw : bool option;  (** Whether or not this video contains sensitive content *)
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
-      previewfile : string option;  (** Video preview file *)
-      privacy : VideoPrivacySet.T.t option;
-      schedule_update : VideoScheduled.Update.t option;
-      support : string option;  (** A text tell the audience how to support the video creator *)
-      tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
-      thumbnailfile : string option;  (** Video thumbnail file *)
-      video_passwords : AddVideoPasswords.T.t option;
-      wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
-      videofile : string;  (** Video file *)
-    }
+    include Types.T
     
     let v ~channel_id ~name ~videofile ?category ?comments_policy ?description ?download_enabled ?generate_transcription ?language ?licence ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?previewfile ?privacy ?schedule_update ?support ?tags ?thumbnailfile ?video_passwords ?wait_transcoding () = { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding; videofile }
     
···
       Jsont.Object.map ~kind:"VideoUploadRequestLegacy"
         (fun category channel_id comments_policy description download_enabled generate_transcription language licence name nsfw nsfw_flags nsfw_summary originally_published_at previewfile privacy schedule_update support tags thumbnailfile video_passwords wait_transcoding videofile -> { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding; videofile })
       |> Jsont.Object.opt_mem "category" VideoCategorySet.T.jsont ~enc:(fun r -> r.category)
-      |> Jsont.Object.mem "channelId" Jsont.int ~enc:(fun r -> r.channel_id)
+      |> Jsont.Object.mem "channelId" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.channel_id)
       |> Jsont.Object.opt_mem "commentsPolicy" VideoCommentsPolicySet.T.jsont ~enc:(fun r -> r.comments_policy)
       |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
       |> Jsont.Object.opt_mem "downloadEnabled" Jsont.bool ~enc:(fun r -> r.download_enabled)
       |> Jsont.Object.opt_mem "generateTranscription" Jsont.bool ~enc:(fun r -> r.generate_transcription)
       |> Jsont.Object.opt_mem "language" VideoLanguageSet.T.jsont ~enc:(fun r -> r.language)
       |> Jsont.Object.opt_mem "licence" VideoLicenceSet.T.jsont ~enc:(fun r -> r.licence)
-      |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.json ~enc:(fun r -> r.nsfw_summary)
···
       |> Jsont.Object.opt_mem "privacy" VideoPrivacySet.T.jsont ~enc:(fun r -> r.privacy)
       |> Jsont.Object.opt_mem "scheduleUpdate" VideoScheduled.Update.jsont ~enc:(fun r -> r.schedule_update)
       |> Jsont.Object.opt_mem "support" Jsont.string ~enc:(fun r -> r.support)
-      |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+      |> Jsont.Object.opt_mem "tags" (Openapi.Runtime.validated_list ~min_items:1 ~max_items:5 ~unique_items:true Jsont.string) ~enc:(fun r -> r.tags)
       |> Jsont.Object.opt_mem "thumbnailfile" Jsont.string ~enc:(fun r -> r.thumbnailfile)
       |> Jsont.Object.opt_mem "videoPasswords" AddVideoPasswords.T.jsont ~enc:(fun r -> r.video_passwords)
       |> Jsont.Object.opt_mem "waitTranscoding" Jsont.bool ~enc:(fun r -> r.wait_transcoding)
···
 end
 
 module VideoUploadRequestCommon = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        category : VideoCategorySet.T.t option;
+        channel_id : int;  (** Channel id that will contain this video *)
+        comments_policy : VideoCommentsPolicySet.T.t option;
+        description : string option;  (** Video description *)
+        download_enabled : bool option;  (** Enable or disable downloading for this video *)
+        generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
+        language : VideoLanguageSet.T.t option;
+        licence : VideoLicenceSet.T.t option;
+        name : string;  (** Video name *)
+        nsfw : bool option;  (** Whether or not this video contains sensitive content *)
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
+        previewfile : string option;  (** Video preview file *)
+        privacy : VideoPrivacySet.T.t option;
+        schedule_update : VideoScheduled.Update.t option;
+        support : string option;  (** A text tell the audience how to support the video creator *)
+        tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
+        thumbnailfile : string option;  (** Video thumbnail file *)
+        video_passwords : AddVideoPasswords.T.t option;
+        wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      category : VideoCategorySet.T.t option;
-      channel_id : int;  (** Channel id that will contain this video *)
-      comments_policy : VideoCommentsPolicySet.T.t option;
-      description : string option;  (** Video description *)
-      download_enabled : bool option;  (** Enable or disable downloading for this video *)
-      generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
-      language : VideoLanguageSet.T.t option;
-      licence : VideoLicenceSet.T.t option;
-      name : string;  (** Video name *)
-      nsfw : bool option;  (** Whether or not this video contains sensitive content *)
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
-      previewfile : string option;  (** Video preview file *)
-      privacy : VideoPrivacySet.T.t option;
-      schedule_update : VideoScheduled.Update.t option;
-      support : string option;  (** A text tell the audience how to support the video creator *)
-      tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
-      thumbnailfile : string option;  (** Video thumbnail file *)
-      video_passwords : AddVideoPasswords.T.t option;
-      wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
-    }
+    include Types.T
     
     let v ~channel_id ~name ?category ?comments_policy ?description ?download_enabled ?generate_transcription ?language ?licence ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?previewfile ?privacy ?schedule_update ?support ?tags ?thumbnailfile ?video_passwords ?wait_transcoding () = { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding }
     
···
       Jsont.Object.map ~kind:"VideoUploadRequestCommon"
         (fun category channel_id comments_policy description download_enabled generate_transcription language licence name nsfw nsfw_flags nsfw_summary originally_published_at previewfile privacy schedule_update support tags thumbnailfile video_passwords wait_transcoding -> { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding })
       |> Jsont.Object.opt_mem "category" VideoCategorySet.T.jsont ~enc:(fun r -> r.category)
-      |> Jsont.Object.mem "channelId" Jsont.int ~enc:(fun r -> r.channel_id)
+      |> Jsont.Object.mem "channelId" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.channel_id)
       |> Jsont.Object.opt_mem "commentsPolicy" VideoCommentsPolicySet.T.jsont ~enc:(fun r -> r.comments_policy)
       |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
       |> Jsont.Object.opt_mem "downloadEnabled" Jsont.bool ~enc:(fun r -> r.download_enabled)
       |> Jsont.Object.opt_mem "generateTranscription" Jsont.bool ~enc:(fun r -> r.generate_transcription)
       |> Jsont.Object.opt_mem "language" VideoLanguageSet.T.jsont ~enc:(fun r -> r.language)
       |> Jsont.Object.opt_mem "licence" VideoLicenceSet.T.jsont ~enc:(fun r -> r.licence)
-      |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.json ~enc:(fun r -> r.nsfw_summary)
···
       |> Jsont.Object.opt_mem "privacy" VideoPrivacySet.T.jsont ~enc:(fun r -> r.privacy)
       |> Jsont.Object.opt_mem "scheduleUpdate" VideoScheduled.Update.jsont ~enc:(fun r -> r.schedule_update)
       |> Jsont.Object.opt_mem "support" Jsont.string ~enc:(fun r -> r.support)
-      |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+      |> Jsont.Object.opt_mem "tags" (Openapi.Runtime.validated_list ~min_items:1 ~max_items:5 ~unique_items:true Jsont.string) ~enc:(fun r -> r.tags)
       |> Jsont.Object.opt_mem "thumbnailfile" Jsont.string ~enc:(fun r -> r.thumbnailfile)
       |> Jsont.Object.opt_mem "videoPasswords" AddVideoPasswords.T.jsont ~enc:(fun r -> r.video_passwords)
       |> Jsont.Object.opt_mem "waitTranscoding" Jsont.bool ~enc:(fun r -> r.wait_transcoding)
···
 end
 
 module VideoCreateImport = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        category : VideoCategorySet.T.t option;
+        channel_id : int;  (** Channel id that will contain this video *)
+        comments_policy : VideoCommentsPolicySet.T.t option;
+        description : string option;  (** Video description *)
+        download_enabled : bool option;  (** Enable or disable downloading for this video *)
+        generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
+        language : VideoLanguageSet.T.t option;
+        licence : VideoLicenceSet.T.t option;
+        name : string;  (** Video name *)
+        nsfw : bool option;  (** Whether or not this video contains sensitive content *)
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
+        previewfile : string option;  (** Video preview file *)
+        privacy : VideoPrivacySet.T.t option;
+        schedule_update : VideoScheduled.Update.t option;
+        support : string option;  (** A text tell the audience how to support the video creator *)
+        tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
+        thumbnailfile : string option;  (** Video thumbnail file *)
+        video_passwords : AddVideoPasswords.T.t option;
+        wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      category : VideoCategorySet.T.t option;
-      channel_id : int;  (** Channel id that will contain this video *)
-      comments_policy : VideoCommentsPolicySet.T.t option;
-      description : string option;  (** Video description *)
-      download_enabled : bool option;  (** Enable or disable downloading for this video *)
-      generate_transcription : bool option;  (** **PeerTube >= 6.2** If enabled by the admin, automatically generate a subtitle of the video *)
-      language : VideoLanguageSet.T.t option;
-      licence : VideoLicenceSet.T.t option;
-      name : string;  (** Video name *)
-      nsfw : bool option;  (** Whether or not this video contains sensitive content *)
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : Jsont.json option;  (** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** Date when the content was originally published *)
-      previewfile : string option;  (** Video preview file *)
-      privacy : VideoPrivacySet.T.t option;
-      schedule_update : VideoScheduled.Update.t option;
-      support : string option;  (** A text tell the audience how to support the video creator *)
-      tags : string list option;  (** Video tags (maximum 5 tags each between 2 and 30 characters) *)
-      thumbnailfile : string option;  (** Video thumbnail file *)
-      video_passwords : AddVideoPasswords.T.t option;
-      wait_transcoding : bool option;  (** Whether or not we wait transcoding before publish the video *)
-    }
+    include Types.T
     
     let v ~channel_id ~name ?category ?comments_policy ?description ?download_enabled ?generate_transcription ?language ?licence ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?previewfile ?privacy ?schedule_update ?support ?tags ?thumbnailfile ?video_passwords ?wait_transcoding () = { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding }
     
···
       Jsont.Object.map ~kind:"VideoCreateImport"
         (fun category channel_id comments_policy description download_enabled generate_transcription language licence name nsfw nsfw_flags nsfw_summary originally_published_at previewfile privacy schedule_update support tags thumbnailfile video_passwords wait_transcoding -> { category; channel_id; comments_policy; description; download_enabled; generate_transcription; language; licence; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; previewfile; privacy; schedule_update; support; tags; thumbnailfile; video_passwords; wait_transcoding })
       |> Jsont.Object.opt_mem "category" VideoCategorySet.T.jsont ~enc:(fun r -> r.category)
-      |> Jsont.Object.mem "channelId" Jsont.int ~enc:(fun r -> r.channel_id)
+      |> Jsont.Object.mem "channelId" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.channel_id)
       |> Jsont.Object.opt_mem "commentsPolicy" VideoCommentsPolicySet.T.jsont ~enc:(fun r -> r.comments_policy)
       |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
       |> Jsont.Object.opt_mem "downloadEnabled" Jsont.bool ~enc:(fun r -> r.download_enabled)
       |> Jsont.Object.opt_mem "generateTranscription" Jsont.bool ~enc:(fun r -> r.generate_transcription)
       |> Jsont.Object.opt_mem "language" VideoLanguageSet.T.jsont ~enc:(fun r -> r.language)
       |> Jsont.Object.opt_mem "licence" VideoLicenceSet.T.jsont ~enc:(fun r -> r.licence)
-      |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.json ~enc:(fun r -> r.nsfw_summary)
···
       |> Jsont.Object.opt_mem "privacy" VideoPrivacySet.T.jsont ~enc:(fun r -> r.privacy)
       |> Jsont.Object.opt_mem "scheduleUpdate" VideoScheduled.Update.jsont ~enc:(fun r -> r.schedule_update)
       |> Jsont.Object.opt_mem "support" Jsont.string ~enc:(fun r -> r.support)
-      |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+      |> Jsont.Object.opt_mem "tags" (Openapi.Runtime.validated_list ~min_items:1 ~max_items:5 ~unique_items:true Jsont.string) ~enc:(fun r -> r.tags)
       |> Jsont.Object.opt_mem "thumbnailfile" Jsont.string ~enc:(fun r -> r.thumbnailfile)
       |> Jsont.Object.opt_mem "videoPasswords" AddVideoPasswords.T.jsont ~enc:(fun r -> r.video_passwords)
       |> Jsont.Object.opt_mem "waitTranscoding" Jsont.bool ~enc:(fun r -> r.wait_transcoding)
···
 end
 
 module ActorImage = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        file_url : string option;  (** **PeerTube >= 7.1** *)
+        height : int option;  (** **PeerTube >= 7.3** *)
+        path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
+        updated_at : Ptime.t option;
+        width : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      file_url : string option;  (** **PeerTube >= 7.1** *)
-      height : int option;  (** **PeerTube >= 7.3** *)
-      path : string option;  (** Deprecated in PeerTube v8.0, use fileUrl instead *)
-      updated_at : Ptime.t option;
-      width : int option;
-    }
+    include Types.T
     
     let v ?created_at ?file_url ?height ?path ?updated_at ?width () = { created_at; file_url; height; path; updated_at; width }
     
···
 end
 
 module VideoChannelSummary = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        display_name : string option;
+        host : string option;
+        id : Id.T.t option;
+        name : string option;
+        url : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      display_name : string option;
-      host : string option;
-      id : Id.T.t option;
-      name : string option;
-      url : string option;
-    }
+    include Types.T
     
     let v ?avatars ?display_name ?host ?id ?name ?url () = { avatars; display_name; host; id; name; url }
     
···
 end
 
 module Actor = struct
+  module Types = struct
+    module Info = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        display_name : string option;
+        host : string option;
+        id : Id.T.t option;
+        name : string option;
+      }
+    end
+  
+    module T = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        created_at : Ptime.t option;
+        followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
+        following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
+        host : string option;  (** server on which the actor is resident *)
+        host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
+        id : Id.T.t option;
+        name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
+        updated_at : Ptime.t option;
+        url : string option;
+      }
+    end
+  end
+  
   module Info = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      display_name : string option;
-      host : string option;
-      id : Id.T.t option;
-      name : string option;
-    }
+    include Types.Info
     
     let v ?avatars ?display_name ?host ?id ?name () = { avatars; display_name; host; id; name }
     
···
   end
   
   module T = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      created_at : Ptime.t option;
-      followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
-      following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
-      host : string option;  (** server on which the actor is resident *)
-      host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
-      id : Id.T.t option;
-      name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
-      updated_at : Ptime.t option;
-      url : string option;
-    }
+    include Types.T
     
     let v ?avatars ?created_at ?followers_count ?following_count ?host ?host_redundancy_allowed ?id ?name ?updated_at ?url () = { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; updated_at; url }
     
···
         (fun avatars created_at followers_count following_count host host_redundancy_allowed id name updated_at url -> { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; updated_at; url })
       |> Jsont.Object.opt_mem "avatars" (Jsont.list ActorImage.T.jsont) ~enc:(fun r -> r.avatars)
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
-      |> Jsont.Object.opt_mem "followersCount" Jsont.int ~enc:(fun r -> r.followers_count)
-      |> Jsont.Object.opt_mem "followingCount" Jsont.int ~enc:(fun r -> r.following_count)
+      |> Jsont.Object.opt_mem "followersCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.followers_count)
+      |> Jsont.Object.opt_mem "followingCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.following_count)
       |> Jsont.Object.opt_mem "host" Jsont.string ~enc:(fun r -> r.host)
       |> Jsont.Object.mem "hostRedundancyAllowed" Openapi.Runtime.nullable_bool
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.host_redundancy_allowed)
···
 end
 
 module Follow = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        follower : Actor.T.t option;
+        following : Actor.T.t option;
+        id : Id.T.t option;
+        score : float option;  (** score reflecting the reachability of the actor, with steps of `10` and a base score of `1000`. *)
+        state : string option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      follower : Actor.T.t option;
-      following : Actor.T.t option;
-      id : Id.T.t option;
-      score : float option;  (** score reflecting the reachability of the actor, with steps of `10` and a base score of `1000`. *)
-      state : string option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?created_at ?follower ?following ?id ?score ?state ?updated_at () = { created_at; follower; following; id; score; state; updated_at }
     
···
 end
 
 module AccountSummary = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        display_name : string option;
+        host : string option;
+        id : int option;
+        name : string option;
+        url : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      display_name : string option;
-      host : string option;
-      id : int option;
-      name : string option;
-      url : string option;
-    }
+    include Types.T
     
     let v ?avatars ?display_name ?host ?id ?name ?url () = { avatars; display_name; host; id; name; url }
     
···
 end
 
 module VideoPlaylist = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        description : string option;
+        display_name : string option;
+        id : Id.T.t option;
+        is_local : bool option;
+        owner_account : AccountSummary.T.t option;
+        privacy : VideoPlaylistPrivacyConstant.T.t option;
+        short_uuid : ShortUuid.T.t option;
+        thumbnail_path : string option;
+        type_ : VideoPlaylistTypeConstant.T.t option;
+        updated_at : Ptime.t option;
+        uuid : Uuidv4.T.t option;
+        video_channel : VideoChannelSummary.T.t option;
+        video_channel_position : int option;  (** Position of the playlist in the channel *)
+        video_length : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      description : string option;
-      display_name : string option;
-      id : Id.T.t option;
-      is_local : bool option;
-      owner_account : AccountSummary.T.t option;
-      privacy : VideoPlaylistPrivacyConstant.T.t option;
-      short_uuid : ShortUuid.T.t option;
-      thumbnail_path : string option;
-      type_ : VideoPlaylistTypeConstant.T.t option;
-      updated_at : Ptime.t option;
-      uuid : Uuidv4.T.t option;
-      video_channel : VideoChannelSummary.T.t option;
-      video_channel_position : int option;  (** Position of the playlist in the channel *)
-      video_length : int option;
-    }
+    include Types.T
     
     let v ?created_at ?description ?display_name ?id ?is_local ?owner_account ?privacy ?short_uuid ?thumbnail_path ?type_ ?updated_at ?uuid ?video_channel ?video_channel_position ?video_length () = { created_at; description; display_name; id; is_local; owner_account; privacy; short_uuid; thumbnail_path; type_; updated_at; uuid; video_channel; video_channel_position; video_length }
     
···
       Jsont.Object.map ~kind:"VideoPlaylist"
         (fun created_at description display_name id is_local owner_account privacy short_uuid thumbnail_path type_ updated_at uuid video_channel video_channel_position video_length -> { created_at; description; display_name; id; is_local; owner_account; privacy; short_uuid; thumbnail_path; type_; updated_at; uuid; video_channel; video_channel_position; video_length })
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
-      |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "description" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:1000 Jsont.string) ~enc:(fun r -> r.description)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:1 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
       |> Jsont.Object.opt_mem "isLocal" Jsont.bool ~enc:(fun r -> r.is_local)
       |> Jsont.Object.opt_mem "ownerAccount" AccountSummary.T.jsont ~enc:(fun r -> r.owner_account)
···
       |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
       |> Jsont.Object.opt_mem "uuid" Uuidv4.T.jsont ~enc:(fun r -> r.uuid)
       |> Jsont.Object.opt_mem "videoChannel" VideoChannelSummary.T.jsont ~enc:(fun r -> r.video_channel)
-      |> Jsont.Object.opt_mem "videoChannelPosition" Jsont.int ~enc:(fun r -> r.video_channel_position)
-      |> Jsont.Object.opt_mem "videoLength" Jsont.int ~enc:(fun r -> r.video_length)
+      |> Jsont.Object.opt_mem "videoChannelPosition" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.video_channel_position)
+      |> Jsont.Object.opt_mem "videoLength" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.video_length)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
   end
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoChannelCollaborator = struct
+  module Types = struct
+    module T = struct
+      (** Representation of a channel collaboration *)
+      type t = {
+        account : AccountSummary.T.t option;
+        created_at : Ptime.t option;
+        id : Id.T.t option;
+        state : Jsont.json option;
+        updated_at : Ptime.t option;
+      }
+    end
+  end
+  
   module T = struct
-    (** Representation of a channel collaboration *)
-    type t = {
-      account : AccountSummary.T.t option;
-      created_at : Ptime.t option;
-      id : Id.T.t option;
-      state : Jsont.json option;
-      updated_at : Ptime.t option;
-    }
+    include Types.T
     
     let v ?account ?created_at ?id ?state ?updated_at () = { account; created_at; id; state; updated_at }
     
···
 end
 
 module Video = struct
+  module Types = struct
+    module Info = struct
+      type t = {
+        id : Jsont.json option;
+        name : Jsont.json option;
+        state : Jsont.json option;
+        uuid : Jsont.json option;
+      }
+    end
+  
+    module T = struct
+      type t = {
+        account : AccountSummary.T.t option;
+        aspect_ratio : float option;  (** **PeerTube >= 6.1** Aspect ratio of the video stream *)
+        blacklisted : bool option;
+        blacklisted_reason : string option;
+        category : VideoConstantNumberCategory.T.t option;  (** category in which the video is classified *)
+        channel : VideoChannelSummary.T.t option;
+        comments : int option;  (** **PeerTube >= 7.2** Number of comments on the video *)
+        created_at : Ptime.t option;  (** time at which the video object was first drafted *)
+        dislikes : int option;
+        duration : int option;  (** duration of the video in seconds *)
+        embed_path : string option;
+        id : Id.T.t option;  (** object id for the video *)
+        is_live : bool option;
+        is_local : bool option;
+        language : VideoConstantStringLanguage.T.t option;  (** main language used in the video *)
+        licence : VideoConstantNumberLicence.T.t option;  (** licence under which the video is distributed *)
+        likes : int option;
+        live_schedules : LiveSchedule.T.t list option;
+        name : string option;  (** title of the video *)
+        nsfw : bool option;
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : string option;  (** **PeerTube >= 7.2** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** used to represent a date of first publication, prior to the practical publication date of `publishedAt` *)
+        preview_path : string option;
+        privacy : VideoPrivacyConstant.T.t option;  (** privacy policy used to distribute the video *)
+        published_at : Ptime.t option;  (** time at which the video was marked as ready for playback (with restrictions depending on `privacy`). Usually set after a `state` evolution. *)
+        scheduled_update : VideoScheduled.Update.t option;
+        short_uuid : ShortUuid.T.t option;
+        state : VideoStateConstant.T.t option;  (** represents the internal state of the video processing within the PeerTube instance *)
+        thumbnail_path : string option;
+        truncated_description : string option;  (** truncated description of the video, written in Markdown.
+       *)
+        updated_at : Ptime.t option;  (** last time the video's metadata was modified *)
+        user_history : Jsont.json option;
+        uuid : Uuidv4.T.t option;  (** universal identifier for the video, that can be used across instances *)
+        views : int option;
+        wait_transcoding : bool option;
+      }
+    end
+  end
+  
   module Info = struct
-    type t = {
-      id : Jsont.json option;
-      name : Jsont.json option;
-      state : Jsont.json option;
-      uuid : Jsont.json option;
-    }
+    include Types.Info
     
     let v ?id ?name ?state ?uuid () = { id; name; state; uuid }
     
···
   end
   
   module T = struct
-    type t = {
-      account : AccountSummary.T.t option;
-      aspect_ratio : float option;  (** **PeerTube >= 6.1** Aspect ratio of the video stream *)
-      blacklisted : bool option;
-      blacklisted_reason : string option;
-      category : VideoConstantNumberCategory.T.t option;  (** category in which the video is classified *)
-      channel : VideoChannelSummary.T.t option;
-      comments : int option;  (** **PeerTube >= 7.2** Number of comments on the video *)
-      created_at : Ptime.t option;  (** time at which the video object was first drafted *)
-      dislikes : int option;
-      duration : int option;  (** duration of the video in seconds *)
-      embed_path : string option;
-      id : Id.T.t option;  (** object id for the video *)
-      is_live : bool option;
-      is_local : bool option;
-      language : VideoConstantStringLanguage.T.t option;  (** main language used in the video *)
-      licence : VideoConstantNumberLicence.T.t option;  (** licence under which the video is distributed *)
-      likes : int option;
-      live_schedules : LiveSchedule.T.t list option;
-      name : string option;  (** title of the video *)
-      nsfw : bool option;
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : string option;  (** **PeerTube >= 7.2** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** used to represent a date of first publication, prior to the practical publication date of `publishedAt` *)
-      preview_path : string option;
-      privacy : VideoPrivacyConstant.T.t option;  (** privacy policy used to distribute the video *)
-      published_at : Ptime.t option;  (** time at which the video was marked as ready for playback (with restrictions depending on `privacy`). Usually set after a `state` evolution. *)
-      scheduled_update : VideoScheduled.Update.t option;
-      short_uuid : ShortUuid.T.t option;
-      state : VideoStateConstant.T.t option;  (** represents the internal state of the video processing within the PeerTube instance *)
-      thumbnail_path : string option;
-      truncated_description : string option;  (** truncated description of the video, written in Markdown.
-     *)
-      updated_at : Ptime.t option;  (** last time the video's metadata was modified *)
-      user_history : Jsont.json option;
-      uuid : Uuidv4.T.t option;  (** universal identifier for the video, that can be used across instances *)
-      views : int option;
-      wait_transcoding : bool option;
-    }
+    include Types.T
     
     let v ?account ?aspect_ratio ?blacklisted ?blacklisted_reason ?category ?channel ?comments ?created_at ?dislikes ?duration ?embed_path ?id ?is_live ?is_local ?language ?licence ?likes ?live_schedules ?name ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?preview_path ?privacy ?published_at ?scheduled_update ?short_uuid ?state ?thumbnail_path ?truncated_description ?updated_at ?user_history ?uuid ?views ?wait_transcoding () = { account; aspect_ratio; blacklisted; blacklisted_reason; category; channel; comments; created_at; dislikes; duration; embed_path; id; is_live; is_local; language; licence; likes; live_schedules; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; preview_path; privacy; published_at; scheduled_update; short_uuid; state; thumbnail_path; truncated_description; updated_at; user_history; uuid; views; wait_transcoding }
     
···
       |> Jsont.Object.opt_mem "licence" VideoConstantNumberLicence.T.jsont ~enc:(fun r -> r.licence)
       |> Jsont.Object.opt_mem "likes" Jsont.int ~enc:(fun r -> r.likes)
       |> Jsont.Object.opt_mem "liveSchedules" (Jsont.list LiveSchedule.T.jsont) ~enc:(fun r -> r.live_schedules)
-      |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.opt_mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.string ~enc:(fun r -> r.nsfw_summary)
···
 end
 
 module VideoRating = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        rating : string;  (** Rating of the video *)
+        video : Video.T.t;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      rating : string;  (** Rating of the video *)
-      video : Video.T.t;
-    }
+    include Types.T
     
     let v ~rating ~video () = { rating; video }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoList = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        data : Video.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      data : Video.T.t list option;
-      total : int option;
-    }
+    include Types.Response
     
     let v ?data ?total () = { data; total }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"VideoListResponse"
         (fun data total -> { data; total })
-      |> Jsont.Object.opt_mem "data" (Jsont.list Video.T.jsont) ~enc:(fun r -> r.data)
+      |> Jsont.Object.opt_mem "data" (Openapi.Runtime.validated_list ~max_items:100 Video.T.jsont) ~enc:(fun r -> r.data)
       |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Search videos 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List watched videos history 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List videos of subscriptions of my user 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List videos of my user 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List videos of a video channel 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List videos 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoImport = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        error : string option;
+        id : Id.T.t option;
+        magnet_uri : string option;  (** magnet URI allowing to resolve the import's source video *)
+        state : VideoImportStateConstant.T.t option;
+        target_url : string option;  (** remote URL where to find the import's source video *)
+        torrent_name : string option;
+        torrentfile : string option;  (** Torrent file containing only the video file *)
+        updated_at : Ptime.t option;
+        video : Video.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      error : string option;
-      id : Id.T.t option;
-      magnet_uri : string option;  (** magnet URI allowing to resolve the import's source video *)
-      state : VideoImportStateConstant.T.t option;
-      target_url : string option;  (** remote URL where to find the import's source video *)
-      torrent_name : string option;
-      torrentfile : string option;  (** Torrent file containing only the video file *)
-      updated_at : Ptime.t option;
-      video : Video.T.t option;
-    }
+    include Types.T
     
     let v ?created_at ?error ?id ?magnet_uri ?state ?target_url ?torrent_name ?torrentfile ?updated_at ?video () = { created_at; error; id; magnet_uri; state; target_url; torrent_name; torrentfile; updated_at; video }
     
···
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
       |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
-      |> Jsont.Object.opt_mem "magnetUri" Jsont.string ~enc:(fun r -> r.magnet_uri)
+      |> Jsont.Object.opt_mem "magnetUri" (Openapi.Runtime.validated_string ~pattern:"/magnet:\\?xt=urn:[a-z0-9]+:[a-z0-9]{32}/i" Jsont.string) ~enc:(fun r -> r.magnet_uri)
       |> Jsont.Object.opt_mem "state" VideoImportStateConstant.T.jsont ~enc:(fun r -> r.state)
       |> Jsont.Object.opt_mem "targetUrl" Jsont.string ~enc:(fun r -> r.target_url)
       |> Jsont.Object.opt_mem "torrentName" Jsont.string ~enc:(fun r -> r.torrent_name)
···
 end
 
 module VideoImportsList = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : VideoImport.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : VideoImport.T.t list option;
-      total : int option;
-    }
+    include Types.T
     
     let v ?data ?total () = { data; total }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"VideoImportsList"
         (fun data total -> { data; total })
-      |> Jsont.Object.opt_mem "data" (Jsont.list VideoImport.T.jsont) ~enc:(fun r -> r.data)
+      |> Jsont.Object.opt_mem "data" (Openapi.Runtime.validated_list ~max_items:100 VideoImport.T.jsont) ~enc:(fun r -> r.data)
       |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoCommentForOwnerOrAdmin = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        account : Jsont.json option;
+        automatic_tags : string list option;
+        created_at : Jsont.json option;
+        held_for_review : Jsont.json option;
+        id : Id.T.t option;
+        in_reply_to_comment_id : Jsont.json option;
+        text : Jsont.json option;
+        thread_id : Jsont.json option;
+        updated_at : Jsont.json option;
+        url : Jsont.json option;
+        video : Video.Info.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      account : Jsont.json option;
-      automatic_tags : string list option;
-      created_at : Jsont.json option;
-      held_for_review : Jsont.json option;
-      id : Id.T.t option;
-      in_reply_to_comment_id : Jsont.json option;
-      text : Jsont.json option;
-      thread_id : Jsont.json option;
-      updated_at : Jsont.json option;
-      url : Jsont.json option;
-      video : Video.Info.t option;
-    }
+    include Types.T
     
     let v ?account ?automatic_tags ?created_at ?held_for_review ?id ?in_reply_to_comment_id ?text ?thread_id ?updated_at ?url ?video () = { account; automatic_tags; created_at; held_for_review; id; in_reply_to_comment_id; text; thread_id; updated_at; url; video }
     
···
 end
 
 module PlaylistElement = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        position : int option;
+        start_timestamp : int option;
+        stop_timestamp : int option;
+        video : Video.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      position : int option;
-      start_timestamp : int option;
-      stop_timestamp : int option;
-      video : Video.T.t option;
-    }
+    include Types.T
     
     let v ?position ?start_timestamp ?stop_timestamp ?video () = { position; start_timestamp; stop_timestamp; video }
     
···
 end
 
 module Notification = struct
+  module Types = struct
+    module Type = struct
+      (** Notification type. One of the following values:
+      
+        - `1` NEW_VIDEO_FROM_SUBSCRIPTION
+      
+        - `2` NEW_COMMENT_ON_MY_VIDEO
+      
+        - `3` NEW_ABUSE_FOR_MODERATORS
+      
+        - `4` BLACKLIST_ON_MY_VIDEO
+      
+        - `5` UNBLACKLIST_ON_MY_VIDEO
+      
+        - `6` MY_VIDEO_PUBLISHED
+      
+        - `7` MY_VIDEO_IMPORT_SUCCESS
+      
+        - `8` MY_VIDEO_IMPORT_ERROR
+      
+        - `9` NEW_USER_REGISTRATION
+      
+        - `10` NEW_FOLLOW
+      
+        - `11` COMMENT_MENTION
+      
+        - `12` VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
+      
+        - `13` NEW_INSTANCE_FOLLOWER
+      
+        - `14` AUTO_INSTANCE_FOLLOWING
+      
+        - `15` ABUSE_STATE_CHANGE
+      
+        - `16` ABUSE_NEW_MESSAGE
+      
+        - `17` NEW_PLUGIN_VERSION
+      
+        - `18` NEW_PEERTUBE_VERSION
+      
+        - `19` MY_VIDEO_STUDIO_EDITION_FINISHED
+      
+        - `20` NEW_USER_REGISTRATION_REQUEST
+      
+        - `21` NEW_LIVE_FROM_SUBSCRIPTION
+      
+        - `22` MY_VIDEO_TRANSCRIPTION_GENERATED
+       *)
+      type t = string
+    end
+  
+    module T = struct
+      type t = {
+        account : Actor.Info.t option;
+        actor_follow : Jsont.json option;
+        comment : Jsont.json option;
+        created_at : Ptime.t option;
+        id : Id.T.t option;
+        read : bool option;
+        type_ : Type.t option;
+        updated_at : Ptime.t option;
+        video : Video.Info.t option;
+        video_abuse : Jsont.json option;
+        video_blacklist : Jsont.json option;
+        video_import : Jsont.json option;
+      }
+    end
+  end
+  
   module Type = struct
-    (** Notification type. One of the following values:
-    
-      - `1` NEW_VIDEO_FROM_SUBSCRIPTION
-    
-      - `2` NEW_COMMENT_ON_MY_VIDEO
-    
-      - `3` NEW_ABUSE_FOR_MODERATORS
-    
-      - `4` BLACKLIST_ON_MY_VIDEO
-    
-      - `5` UNBLACKLIST_ON_MY_VIDEO
-    
-      - `6` MY_VIDEO_PUBLISHED
-    
-      - `7` MY_VIDEO_IMPORT_SUCCESS
-    
-      - `8` MY_VIDEO_IMPORT_ERROR
-    
-      - `9` NEW_USER_REGISTRATION
-    
-      - `10` NEW_FOLLOW
-    
-      - `11` COMMENT_MENTION
-    
-      - `12` VIDEO_AUTO_BLACKLIST_FOR_MODERATORS
-    
-      - `13` NEW_INSTANCE_FOLLOWER
-    
-      - `14` AUTO_INSTANCE_FOLLOWING
-    
-      - `15` ABUSE_STATE_CHANGE
-    
-      - `16` ABUSE_NEW_MESSAGE
-    
-      - `17` NEW_PLUGIN_VERSION
-    
-      - `18` NEW_PEERTUBE_VERSION
-    
-      - `19` MY_VIDEO_STUDIO_EDITION_FINISHED
-    
-      - `20` NEW_USER_REGISTRATION_REQUEST
-    
-      - `21` NEW_LIVE_FROM_SUBSCRIPTION
-    
-      - `22` MY_VIDEO_TRANSCRIPTION_GENERATED
-     *)
-    type t = string
-    
+    include Types.Type
     let jsont = Jsont.string
   end
   
   module T = struct
-    type t = {
-      account : Actor.Info.t option;
-      actor_follow : Jsont.json option;
-      comment : Jsont.json option;
-      created_at : Ptime.t option;
-      id : Id.T.t option;
-      read : bool option;
-      type_ : Type.t option;
-      updated_at : Ptime.t option;
-      video : Video.Info.t option;
-      video_abuse : Jsont.json option;
-      video_blacklist : Jsont.json option;
-      video_import : Jsont.json option;
-    }
+    include Types.T
     
     let v ?account ?actor_follow ?comment ?created_at ?id ?read ?type_ ?updated_at ?video ?video_abuse ?video_blacklist ?video_import () = { account; actor_follow; comment; created_at; id; read; type_; updated_at; video; video_abuse; video_blacklist; video_import }
     
···
 end
 
 module NotificationList = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        data : Notification.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      data : Notification.T.t list option;
-      total : int option;
-    }
+    include Types.Response
     
     let v ?data ?total () = { data; total }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"NotificationListResponse"
         (fun data total -> { data; total })
-      |> Jsont.Object.opt_mem "data" (Jsont.list Notification.T.jsont) ~enc:(fun r -> r.data)
+      |> Jsont.Object.opt_mem "data" (Openapi.Runtime.validated_list ~max_items:100 Notification.T.jsont) ~enc:(fun r -> r.data)
       |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module AbuseMessage = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        account : AccountSummary.T.t option;
+        by_moderator : bool option;
+        created_at : Ptime.t option;
+        id : Id.T.t option;
+        message : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      account : AccountSummary.T.t option;
-      by_moderator : bool option;
-      created_at : Ptime.t option;
-      id : Id.T.t option;
-      message : string option;
-    }
+    include Types.T
     
     let v ?account ?by_moderator ?created_at ?id ?message () = { account; by_moderator; created_at; id; message }
     
···
       |> Jsont.Object.opt_mem "byModerator" Jsont.bool ~enc:(fun r -> r.by_moderator)
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
-      |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
+      |> Jsont.Object.opt_mem "message" (Openapi.Runtime.validated_string ~min_length:2 ~max_length:3000 Jsont.string) ~enc:(fun r -> r.message)
       |> Jsont.Object.skip_unknown
       |> Jsont.Object.finish
   end
 end
 
 module Account = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        created_at : Ptime.t option;
+        followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
+        following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
+        host : string option;  (** server on which the actor is resident *)
+        host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
+        id : Id.T.t option;
+        name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
+        updated_at : Ptime.t option;
+        url : string option;
+        user_id : Jsont.json option;  (** object id for the user tied to this account *)
+        display_name : string option;  (** editable name of the account, displayed in its representations *)
+        description : string option;  (** text or bio displayed on the account's profile *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      created_at : Ptime.t option;
-      followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
-      following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
-      host : string option;  (** server on which the actor is resident *)
-      host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
-      id : Id.T.t option;
-      name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
-      updated_at : Ptime.t option;
-      url : string option;
-      user_id : Jsont.json option;  (** object id for the user tied to this account *)
-      display_name : string option;  (** editable name of the account, displayed in its representations *)
-      description : string option;  (** text or bio displayed on the account's profile *)
-    }
+    include Types.T
     
     let v ?avatars ?created_at ?followers_count ?following_count ?host ?host_redundancy_allowed ?id ?name ?updated_at ?url ?user_id ?display_name ?description () = { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; updated_at; url; user_id; display_name; description }
     
···
         (fun avatars created_at followers_count following_count host host_redundancy_allowed id name updated_at url user_id display_name description -> { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; updated_at; url; user_id; display_name; description })
       |> Jsont.Object.opt_mem "avatars" (Jsont.list ActorImage.T.jsont) ~enc:(fun r -> r.avatars)
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
-      |> Jsont.Object.opt_mem "followersCount" Jsont.int ~enc:(fun r -> r.followers_count)
-      |> Jsont.Object.opt_mem "followingCount" Jsont.int ~enc:(fun r -> r.following_count)
+      |> Jsont.Object.opt_mem "followersCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.followers_count)
+      |> Jsont.Object.opt_mem "followingCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.following_count)
       |> Jsont.Object.opt_mem "host" Jsont.string ~enc:(fun r -> r.host)
       |> Jsont.Object.mem "hostRedundancyAllowed" Openapi.Runtime.nullable_bool
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.host_redundancy_allowed)
···
       |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
       |> Jsont.Object.opt_mem "url" Jsont.string ~enc:(fun r -> r.url)
       |> Jsont.Object.opt_mem "userId" Jsont.json ~enc:(fun r -> r.user_id)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
       |> Jsont.Object.skip_unknown
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoComment = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        account : Account.T.t option;
+        created_at : Ptime.t option;
+        deleted_at : Ptime.t option;
+        held_for_review : bool option;
+        id : Id.T.t option;
+        in_reply_to_comment_id : Id.T.t option;
+        is_deleted : bool;
+        text : string option;  (** Text of the comment *)
+        thread_id : Id.T.t option;
+        total_replies : int option;
+        total_replies_from_video_author : int option;
+        updated_at : Ptime.t option;
+        url : string option;
+        video_id : Jsont.json option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      account : Account.T.t option;
-      created_at : Ptime.t option;
-      deleted_at : Ptime.t option;
-      held_for_review : bool option;
-      id : Id.T.t option;
-      in_reply_to_comment_id : Id.T.t option;
-      is_deleted : bool option;
-      text : string option;  (** Text of the comment *)
-      thread_id : Id.T.t option;
-      total_replies : int option;
-      total_replies_from_video_author : int option;
-      updated_at : Ptime.t option;
-      url : string option;
-      video_id : Jsont.json option;
-    }
+    include Types.T
     
-    let v ?account ?created_at ?deleted_at ?held_for_review ?id ?in_reply_to_comment_id ?is_deleted ?text ?thread_id ?total_replies ?total_replies_from_video_author ?updated_at ?url ?video_id () = { account; created_at; deleted_at; held_for_review; id; in_reply_to_comment_id; is_deleted; text; thread_id; total_replies; total_replies_from_video_author; updated_at; url; video_id }
+    let v ?(deleted_at=None) ?(is_deleted=false) ?account ?created_at ?held_for_review ?id ?in_reply_to_comment_id ?text ?thread_id ?total_replies ?total_replies_from_video_author ?updated_at ?url ?video_id () = { account; created_at; deleted_at; held_for_review; id; in_reply_to_comment_id; is_deleted; text; thread_id; total_replies; total_replies_from_video_author; updated_at; url; video_id }
     
     let account t = t.account
     let created_at t = t.created_at
···
       |> Jsont.Object.opt_mem "heldForReview" Jsont.bool ~enc:(fun r -> r.held_for_review)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
       |> Jsont.Object.opt_mem "inReplyToCommentId" Id.T.jsont ~enc:(fun r -> r.in_reply_to_comment_id)
-      |> Jsont.Object.opt_mem "isDeleted" Jsont.bool ~enc:(fun r -> r.is_deleted)
-      |> Jsont.Object.opt_mem "text" Jsont.string ~enc:(fun r -> r.text)
+      |> Jsont.Object.mem "isDeleted" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.is_deleted)
+      |> Jsont.Object.opt_mem "text" (Openapi.Runtime.validated_string ~min_length:1 Jsont.string) ~enc:(fun r -> r.text)
       |> Jsont.Object.opt_mem "threadId" Id.T.jsont ~enc:(fun r -> r.thread_id)
-      |> Jsont.Object.opt_mem "totalReplies" Jsont.int ~enc:(fun r -> r.total_replies)
-      |> Jsont.Object.opt_mem "totalRepliesFromVideoAuthor" Jsont.int ~enc:(fun r -> r.total_replies_from_video_author)
+      |> Jsont.Object.opt_mem "totalReplies" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.total_replies)
+      |> Jsont.Object.opt_mem "totalRepliesFromVideoAuthor" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.total_replies_from_video_author)
       |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
       |> Jsont.Object.opt_mem "url" Jsont.string ~enc:(fun r -> r.url)
       |> Jsont.Object.opt_mem "videoId" Jsont.json ~enc:(fun r -> r.video_id)
···
 end
 
 module VideoCommentThreadTree = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        children : Jsont.json list option;
+        comment : VideoComment.T.t option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      children : Jsont.json list option;
-      comment : VideoComment.T.t option;
-    }
+    include Types.T
     
     let v ?children ?comment () = { children; comment }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module CommentThreadPost = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        comment : VideoComment.T.t option;
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      comment : VideoComment.T.t option;
-    }
+    include Types.Response
     
     let v ?comment () = { comment }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reply to a thread of a video 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module CommentThread = struct
+  module Types = struct
+    module Response = struct
+      type t = {
+        data : VideoComment.T.t list option;
+        total : int option;  (** Total threads (included deleted ones) on this video *)
+        total_not_deleted_comments : int option;  (** Total not-deleted threads (included deleted ones) on this video *)
+      }
+    end
+  end
+  
   module Response = struct
-    type t = {
-      data : VideoComment.T.t list option;
-      total : int option;  (** Total threads (included deleted ones) on this video *)
-      total_not_deleted_comments : int option;  (** Total not-deleted threads (included deleted ones) on this video *)
-    }
+    include Types.Response
     
     let v ?data ?total ?total_not_deleted_comments () = { data; total; total_not_deleted_comments }
     
···
     let jsont : t Jsont.t =
       Jsont.Object.map ~kind:"CommentThreadResponse"
         (fun data total total_not_deleted_comments -> { data; total; total_not_deleted_comments })
-      |> Jsont.Object.opt_mem "data" (Jsont.list VideoComment.T.jsont) ~enc:(fun r -> r.data)
+      |> Jsont.Object.opt_mem "data" (Openapi.Runtime.validated_list ~max_items:100 VideoComment.T.jsont) ~enc:(fun r -> r.data)
       |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
       |> Jsont.Object.opt_mem "totalNotDeletedComments" Jsont.int ~enc:(fun r -> r.total_not_deleted_comments)
       |> Jsont.Object.skip_unknown
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoChannel = struct
+  module Types = struct
+    module Update = struct
+      type t = {
+        description : Jsont.json option;  (** Channel description *)
+        display_name : Jsont.json option;  (** Channel display name *)
+        support : Jsont.json option;  (** How to support/fund the channel *)
+        bulk_videos_support_update : bool option;  (** Update the support field for all videos of this channel *)
+      }
+    end
+  
+    module Create = struct
+      type t = {
+        description : Jsont.json option;  (** Channel description *)
+        display_name : Jsont.json;  (** Channel display name *)
+        support : Jsont.json option;  (** How to support/fund the channel *)
+        name : UsernameChannel.T.t;  (** username of the channel to create *)
+      }
+    end
+  
+    module T = struct
+      type t = {
+        avatars : ActorImage.T.t list option;
+        created_at : Ptime.t option;
+        followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
+        following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
+        host : string option;  (** server on which the actor is resident *)
+        host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
+        id : Id.T.t option;
+        name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
+        url : string option;
+        display_name : string option;  (** editable name of the channel, displayed in its representations *)
+        description : string option;
+        support : string option;  (** text shown by default on all videos of this channel, to tell the audience how to support it *)
+        is_local : bool option;
+        updated_at : Ptime.t option;
+        banners : ActorImage.T.t list option;
+        owner_account : Account.T.t option;
+      }
+    end
+  end
+  
   module Update = struct
-    type t = {
-      description : Jsont.json option;  (** Channel description *)
-      display_name : Jsont.json option;  (** Channel display name *)
-      support : Jsont.json option;  (** How to support/fund the channel *)
-      bulk_videos_support_update : bool option;  (** Update the support field for all videos of this channel *)
-    }
+    include Types.Update
     
     let v ?description ?display_name ?support ?bulk_videos_support_update () = { description; display_name; support; bulk_videos_support_update }
     
···
   end
   
   module Create = struct
-    type t = {
-      description : Jsont.json option;  (** Channel description *)
-      display_name : Jsont.json;  (** Channel display name *)
-      support : Jsont.json option;  (** How to support/fund the channel *)
-      name : UsernameChannel.T.t;  (** username of the channel to create *)
-    }
+    include Types.Create
     
     let v ~display_name ~name ?description ?support () = { description; display_name; support; name }
     
···
   end
   
   module T = struct
-    type t = {
-      avatars : ActorImage.T.t list option;
-      created_at : Ptime.t option;
-      followers_count : int option;  (** number of followers of this actor, as seen by this instance *)
-      following_count : int option;  (** number of actors subscribed to by this actor, as seen by this instance *)
-      host : string option;  (** server on which the actor is resident *)
-      host_redundancy_allowed : bool option;  (** whether this actor's host allows redundancy of its videos *)
-      id : Id.T.t option;
-      name : Username.T.t option;  (** immutable name of the actor, used to find or mention it *)
-      url : string option;
-      display_name : string option;  (** editable name of the channel, displayed in its representations *)
-      description : string option;
-      support : string option;  (** text shown by default on all videos of this channel, to tell the audience how to support it *)
-      is_local : bool option;
-      updated_at : Ptime.t option;
-      banners : ActorImage.T.t list option;
-      owner_account : Account.T.t option;
-    }
+    include Types.T
     
     let v ?avatars ?created_at ?followers_count ?following_count ?host ?host_redundancy_allowed ?id ?name ?url ?display_name ?description ?support ?is_local ?updated_at ?banners ?owner_account () = { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; url; display_name; description; support; is_local; updated_at; banners; owner_account }
     
···
         (fun avatars created_at followers_count following_count host host_redundancy_allowed id name url display_name description support is_local updated_at banners owner_account -> { avatars; created_at; followers_count; following_count; host; host_redundancy_allowed; id; name; url; display_name; description; support; is_local; updated_at; banners; owner_account })
       |> Jsont.Object.opt_mem "avatars" (Jsont.list ActorImage.T.jsont) ~enc:(fun r -> r.avatars)
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
-      |> Jsont.Object.opt_mem "followersCount" Jsont.int ~enc:(fun r -> r.followers_count)
-      |> Jsont.Object.opt_mem "followingCount" Jsont.int ~enc:(fun r -> r.following_count)
+      |> Jsont.Object.opt_mem "followersCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.followers_count)
+      |> Jsont.Object.opt_mem "followingCount" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.following_count)
       |> Jsont.Object.opt_mem "host" Jsont.string ~enc:(fun r -> r.host)
       |> Jsont.Object.mem "hostRedundancyAllowed" Openapi.Runtime.nullable_bool
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.host_redundancy_allowed)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
       |> Jsont.Object.opt_mem "name" Username.T.jsont ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "url" Jsont.string ~enc:(fun r -> r.url)
-      |> Jsont.Object.opt_mem "displayName" Jsont.string ~enc:(fun r -> r.display_name)
+      |> Jsont.Object.opt_mem "displayName" (Openapi.Runtime.validated_string ~min_length:1 ~max_length:120 Jsont.string) ~enc:(fun r -> r.display_name)
       |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
       |> Jsont.Object.mem "support" Openapi.Runtime.nullable_string
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get a video channel 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoDetails = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        aspect_ratio : float option;  (** **PeerTube >= 6.1** Aspect ratio of the video stream *)
+        blacklisted : bool option;
+        blacklisted_reason : string option;
+        category : VideoConstantNumberCategory.T.t option;  (** category in which the video is classified *)
+        comments : int option;  (** **PeerTube >= 7.2** Number of comments on the video *)
+        created_at : Ptime.t option;  (** time at which the video object was first drafted *)
+        dislikes : int option;
+        duration : int option;  (** duration of the video in seconds *)
+        embed_path : string option;
+        id : Id.T.t option;  (** object id for the video *)
+        is_live : bool option;
+        is_local : bool option;
+        language : VideoConstantStringLanguage.T.t option;  (** main language used in the video *)
+        licence : VideoConstantNumberLicence.T.t option;  (** licence under which the video is distributed *)
+        likes : int option;
+        live_schedules : LiveSchedule.T.t list option;
+        name : string option;  (** title of the video *)
+        nsfw : bool option;
+        nsfw_flags : Nsfwflag.T.t option;
+        nsfw_summary : string option;  (** **PeerTube >= 7.2** More information about the sensitive content of the video *)
+        originally_published_at : Ptime.t option;  (** used to represent a date of first publication, prior to the practical publication date of `publishedAt` *)
+        preview_path : string option;
+        privacy : VideoPrivacyConstant.T.t option;  (** privacy policy used to distribute the video *)
+        published_at : Ptime.t option;  (** time at which the video was marked as ready for playback (with restrictions depending on `privacy`). Usually set after a `state` evolution. *)
+        scheduled_update : VideoScheduled.Update.t option;
+        short_uuid : ShortUuid.T.t option;
+        state : VideoStateConstant.T.t option;  (** represents the internal state of the video processing within the PeerTube instance *)
+        thumbnail_path : string option;
+        truncated_description : string option;  (** truncated description of the video, written in Markdown.
+       *)
+        updated_at : Ptime.t option;  (** last time the video's metadata was modified *)
+        user_history : Jsont.json option;
+        uuid : Uuidv4.T.t option;  (** universal identifier for the video, that can be used across instances *)
+        views : int option;
+        wait_transcoding : bool option;
+        viewers : int option;  (** If the video is a live, you have the amount of current viewers *)
+        description : string option;  (** full description of the video, written in Markdown.
+       *)
+        support : string option;  (** A text tell the audience how to support the video creator *)
+        channel : VideoChannel.T.t option;
+        account : Account.T.t option;
+        tags : string list option;
+        comments_policy : VideoCommentsPolicyConstant.T.t option;
+        download_enabled : bool option;
+        input_file_updated_at : Ptime.t option;  (** Latest input file update. Null if the file has never been replaced since the original upload *)
+        tracker_urls : string list option;
+        files : VideoFile.T.t list option;  (** Web compatible video files. If Web Video is disabled on the server:
+      
+      - field will be empty
+      - video files will be found in `streamingPlaylists[].files` field
+       *)
+        streaming_playlists : VideoStreamingPlaylists.T.t list option;  (** HLS playlists/manifest files. If HLS is disabled on the server:
+      
+      - field will be empty
+      - video files will be found in `files` field
+       *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      aspect_ratio : float option;  (** **PeerTube >= 6.1** Aspect ratio of the video stream *)
-      blacklisted : bool option;
-      blacklisted_reason : string option;
-      category : VideoConstantNumberCategory.T.t option;  (** category in which the video is classified *)
-      comments : int option;  (** **PeerTube >= 7.2** Number of comments on the video *)
-      created_at : Ptime.t option;  (** time at which the video object was first drafted *)
-      dislikes : int option;
-      duration : int option;  (** duration of the video in seconds *)
-      embed_path : string option;
-      id : Id.T.t option;  (** object id for the video *)
-      is_live : bool option;
-      is_local : bool option;
-      language : VideoConstantStringLanguage.T.t option;  (** main language used in the video *)
-      licence : VideoConstantNumberLicence.T.t option;  (** licence under which the video is distributed *)
-      likes : int option;
-      live_schedules : LiveSchedule.T.t list option;
-      name : string option;  (** title of the video *)
-      nsfw : bool option;
-      nsfw_flags : Nsfwflag.T.t option;
-      nsfw_summary : string option;  (** **PeerTube >= 7.2** More information about the sensitive content of the video *)
-      originally_published_at : Ptime.t option;  (** used to represent a date of first publication, prior to the practical publication date of `publishedAt` *)
-      preview_path : string option;
-      privacy : VideoPrivacyConstant.T.t option;  (** privacy policy used to distribute the video *)
-      published_at : Ptime.t option;  (** time at which the video was marked as ready for playback (with restrictions depending on `privacy`). Usually set after a `state` evolution. *)
-      scheduled_update : VideoScheduled.Update.t option;
-      short_uuid : ShortUuid.T.t option;
-      state : VideoStateConstant.T.t option;  (** represents the internal state of the video processing within the PeerTube instance *)
-      thumbnail_path : string option;
-      truncated_description : string option;  (** truncated description of the video, written in Markdown.
-     *)
-      updated_at : Ptime.t option;  (** last time the video's metadata was modified *)
-      user_history : Jsont.json option;
-      uuid : Uuidv4.T.t option;  (** universal identifier for the video, that can be used across instances *)
-      views : int option;
-      wait_transcoding : bool option;
-      viewers : int option;  (** If the video is a live, you have the amount of current viewers *)
-      description : string option;  (** full description of the video, written in Markdown.
-     *)
-      support : string option;  (** A text tell the audience how to support the video creator *)
-      channel : VideoChannel.T.t option;
-      account : Account.T.t option;
-      tags : string list option;
-      comments_policy : VideoCommentsPolicyConstant.T.t option;
-      download_enabled : bool option;
-      input_file_updated_at : Ptime.t option;  (** Latest input file update. Null if the file has never been replaced since the original upload *)
-      tracker_urls : string list option;
-      files : VideoFile.T.t list option;  (** Web compatible video files. If Web Video is disabled on the server:
-    
-    - field will be empty
-    - video files will be found in `streamingPlaylists[].files` field
-     *)
-      streaming_playlists : VideoStreamingPlaylists.T.t list option;  (** HLS playlists/manifest files. If HLS is disabled on the server:
-    
-    - field will be empty
-    - video files will be found in `files` field
-     *)
-    }
+    include Types.T
     
     let v ?aspect_ratio ?blacklisted ?blacklisted_reason ?category ?comments ?created_at ?dislikes ?duration ?embed_path ?id ?is_live ?is_local ?language ?licence ?likes ?live_schedules ?name ?nsfw ?nsfw_flags ?nsfw_summary ?originally_published_at ?preview_path ?privacy ?published_at ?scheduled_update ?short_uuid ?state ?thumbnail_path ?truncated_description ?updated_at ?user_history ?uuid ?views ?wait_transcoding ?viewers ?description ?support ?channel ?account ?tags ?comments_policy ?download_enabled ?input_file_updated_at ?tracker_urls ?files ?streaming_playlists () = { aspect_ratio; blacklisted; blacklisted_reason; category; comments; created_at; dislikes; duration; embed_path; id; is_live; is_local; language; licence; likes; live_schedules; name; nsfw; nsfw_flags; nsfw_summary; originally_published_at; preview_path; privacy; published_at; scheduled_update; short_uuid; state; thumbnail_path; truncated_description; updated_at; user_history; uuid; views; wait_transcoding; viewers; description; support; channel; account; tags; comments_policy; download_enabled; input_file_updated_at; tracker_urls; files; streaming_playlists }
     
···
       |> Jsont.Object.opt_mem "licence" VideoConstantNumberLicence.T.jsont ~enc:(fun r -> r.licence)
       |> Jsont.Object.opt_mem "likes" Jsont.int ~enc:(fun r -> r.likes)
       |> Jsont.Object.opt_mem "liveSchedules" (Jsont.list LiveSchedule.T.jsont) ~enc:(fun r -> r.live_schedules)
-      |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
+      |> Jsont.Object.opt_mem "name" (Openapi.Runtime.validated_string ~min_length:3 ~max_length:120 Jsont.string) ~enc:(fun r -> r.name)
       |> Jsont.Object.opt_mem "nsfw" Jsont.bool ~enc:(fun r -> r.nsfw)
       |> Jsont.Object.opt_mem "nsfwFlags" Nsfwflag.T.jsont ~enc:(fun r -> r.nsfw_flags)
       |> Jsont.Object.opt_mem "nsfwSummary" Jsont.string ~enc:(fun r -> r.nsfw_summary)
···
            ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.support)
       |> Jsont.Object.opt_mem "channel" VideoChannel.T.jsont ~enc:(fun r -> r.channel)
       |> Jsont.Object.opt_mem "account" Account.T.jsont ~enc:(fun r -> r.account)
-      |> Jsont.Object.opt_mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
+      |> Jsont.Object.opt_mem "tags" (Openapi.Runtime.validated_list ~min_items:1 ~max_items:5 Jsont.string) ~enc:(fun r -> r.tags)
       |> Jsont.Object.opt_mem "commentsPolicy" VideoCommentsPolicyConstant.T.jsont ~enc:(fun r -> r.comments_policy)
       |> Jsont.Object.opt_mem "downloadEnabled" Jsont.bool ~enc:(fun r -> r.download_enabled)
       |> Jsont.Object.mem "inputFileUpdatedAt" Openapi.Runtime.nullable_ptime
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let status = Requests.Response.status_code response in
+      let parsed_body = match status with
+        | 401 ->
+            (match Openapi.Runtime.Json.decode_json ServerError.T.jsont (Requests.Response.json response) with
+             | Ok v -> Some (Openapi.Runtime.Typed ("ServerError", Openapi.Runtime.Json.encode_json ServerError.T.jsont v))
+             | Error _ -> None)
+        | 403 ->
+            (match Openapi.Runtime.Json.decode_json ServerError.T.jsont (Requests.Response.json response) with
+             | Ok v -> Some (Openapi.Runtime.Typed ("ServerError", Openapi.Runtime.Json.encode_json ServerError.T.jsont v))
+             | Error _ -> None)
+        | _ ->
+            (match Jsont_bytesrw.decode_string Jsont.json body with
+             | Ok json -> Some (Openapi.Runtime.Json json)
+             | Error _ -> Some (Openapi.Runtime.Raw body))
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
-        status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        status;
+        body;
+        parsed_body;
       })
 end
 
 module VideoChannelSync = struct
+  module Types = struct
+    module Create = struct
+      type t = {
+        external_channel_url : string option;
+        video_channel_id : Id.T.t option;
+      }
+    end
+  
+    module T = struct
+      type t = {
+        channel : VideoChannel.T.t option;
+        created_at : Ptime.t option;
+        external_channel_url : string option;
+        id : Id.T.t option;
+        last_sync_at : Ptime.t option;
+        state : Jsont.json option;
+      }
+    end
+  end
+  
   module Create = struct
-    type t = {
-      external_channel_url : string option;
-      video_channel_id : Id.T.t option;
-    }
+    include Types.Create
     
     let v ?external_channel_url ?video_channel_id () = { external_channel_url; video_channel_id }
     
···
   end
   
   module T = struct
-    type t = {
-      channel : VideoChannel.T.t option;
-      created_at : Ptime.t option;
-      external_channel_url : string option;
-      id : Id.T.t option;
-      last_sync_at : Ptime.t option;
-      state : Jsont.json option;
-    }
+    include Types.T
     
     let v ?channel ?created_at ?external_channel_url ?id ?last_sync_at ?state () = { channel; created_at; external_channel_url; id; last_sync_at; state }
     
···
 end
 
 module VideoChannelSyncList = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : VideoChannelSync.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : VideoChannelSync.T.t list option;
-      total : int option;
-    }
+    include Types.T
     
     let v ?data ?total () = { data; total }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Report an abuse *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update an abuse 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete an abuse 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List messages of an abuse 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add message to an abuse 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete an abuse message 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List accounts 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List followers of an account 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List playlists of an account 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update account auto tag policies on comments
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update client language
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Set instance runtime configuration *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete instance runtime configuration *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete instance avatar *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update instance avatar *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete instance banner *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update instance banner *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete instance logo *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update instance logo *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Set instance custom homepage *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Pause job queue *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Resume job queue *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List instance jobs 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create playback metrics
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Install a plugin *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Uninstall a plugin *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a plugin *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get a plugin's public settings 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get a plugin's registered settings 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Set a plugin's settings 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List runners 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List jobs 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Request a new job
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a job
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Abort job
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Accept job
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Cancel a job *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Post job error
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Post job success
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update job
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Register a new runner
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List registration tokens 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Generate registration token
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Remove registration token
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Unregister a runner
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a runner *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Search playlists 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get instance audit logs *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List account blocks 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Block an account *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Unblock an account by its handle 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List server blocks 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Block a server *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Unblock a server by its domain 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List instances following the server 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Remove or reject a follower to your server 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Accept a pending follower to your server 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reject a pending follower to your server 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List instances followed by the server 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Follow a list of actors (PeerTube instance, channel or account) *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Unfollow an actor (PeerTube instance, channel or account) 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get instance logs *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Send client log *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Mirror a video *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a mirror done on a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a server redundancy policy 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Ask to reset password
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Resend user verification link *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update my user information *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List my abuses 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete my avatar *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update my user avatar *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Clear video history *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete history element *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Mark feature info as read
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update my notification settings *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Mark notifications as read by their id *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Mark all my notification as read *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add subscription to my user *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get if subscriptions exist for my user 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete subscription of my user 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Check video exists in my playlists 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get my user used quota *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List comments on user's videos
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Register a user
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List registrations 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Resend verification link to registration request email *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete registration
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Accept registration 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reject registration 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Verify a registration email
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Logout
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Login
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get a user 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a user 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a user 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reset password 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List token sessions 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List token sessions 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Confirm two factor auth
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Disable two factor auth
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Verify a user
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List user exports
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Request user export
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a user export
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Initialize the resumable user import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Send chunk for the resumable user import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Cancel the resumable user import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get latest user import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a synchronization for a video channel *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video channel synchronization 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Triggers the channel synchronization job, fetching all the videos from the remote channel 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a video channel *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a video channel 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video channel 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete channel avatar 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update channel avatar 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete channel banner 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update channel banner 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** *List channel collaborators
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Invite a collaborator
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Remove a channel collaborator
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Accept a collaboration invitation
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reject a collaboration invitation
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List followers of a video channel 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Import videos in channel
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List playlists of a channel 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reorder channel playlists 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List video playlists 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a video playlist
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available playlist privacy policies *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a video playlist
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video playlist 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List videos of a playlist 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add a video in a playlist 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Reorder playlist elements 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a playlist element 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete an element from a playlist 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List video blocks 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available video categories *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List instance comments 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete video import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Cancel video import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Retry video import
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available video languages *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available video licences *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update information about a live 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List live sessions
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List video ownership changes *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Accept ownership change request 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Refuse ownership change request 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List available video privacy policies *)
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Initialize the resumable upload of a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Cancel the resumable upload of a video, deleting any data uploaded so far
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Block a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Unblock a video by its id 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List captions of a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Generate a video caption
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add or replace a video caption 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video caption 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Replace video chapters
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a comment or a reply 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Approve a comment
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get complete video description 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Request ownership change 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete video HLS files 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List video passwords
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add a video password
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update video passwords
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete a video password
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Like/dislike a video 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete video source file 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Initialize the resumable replacement of a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Send chunk for the resumable replacement of a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Cancel the resumable replacement of a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List storyboards of a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a studio task
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Create a transcoding job 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Notify user is watching a video
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete video Web Video files
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List account watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add account watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update account watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete account watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List server watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Add server watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "POST";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Update server watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "PUT";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Delete server watched words
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "DELETE";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Download video file
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Videos podcast feed 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Videos of subscriptions feeds 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Comments on videos feeds 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Common videos feeds 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get private HLS video file 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get public HLS video file 
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get private Web Video file
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get public Web Video file
···
     if Requests.Response.ok response then
       Requests.Response.json response
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module VideoChannelList = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        data : VideoChannel.T.t list option;
+        total : int option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      data : VideoChannel.T.t list option;
-      total : int option;
-    }
+    include Types.T
     
     let v ?data ?total () = { data; total }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Search channels 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List my user subscriptions 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** List video channels 
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module UserWithStats = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        account : Account.T.t option;
+        admin_flags : UserAdminFlags.T.t option;
+        auto_play_next_video : bool option;  (** Automatically start playing the upcoming video after the currently playing video *)
+        auto_play_next_video_playlist : bool option;  (** Automatically start playing the video on the playlist after the currently playing video *)
+        auto_play_video : bool option;  (** Automatically start playing the video on the watch page *)
+        blocked : bool option;
+        blocked_reason : string option;
+        created_at : string option;
+        email : string option;  (** The user email *)
+        email_public : bool option;  (** Has the user accepted to display the email publicly? *)
+        email_verified : bool option;  (** Has the user confirmed their email address? *)
+        id : Id.T.t option;
+        language : string option;  (** default language for this user *)
+        last_login_date : Ptime.t option;
+        new_features_info_read : float option;  (** New features information the user has read *)
+        no_account_setup_warning_modal : bool option;
+        no_instance_config_warning_modal : bool option;
+        no_welcome_modal : bool option;
+        notification_settings : UserNotificationSettings.T.t option;
+        nsfw_flags_blurred : Nsfwflag.T.t option;
+        nsfw_flags_displayed : Nsfwflag.T.t option;
+        nsfw_flags_hidden : Nsfwflag.T.t option;
+        nsfw_flags_warned : Nsfwflag.T.t option;
+        nsfw_policy : Nsfwpolicy.T.t option;
+        p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
+        plugin_auth : string option;  (** Auth plugin to use to authenticate the user *)
+        role : Jsont.json option;
+        theme : string option;  (** Theme enabled by this user *)
+        two_factor_enabled : bool option;  (** Whether the user has enabled two-factor authentication or not *)
+        username : Username.T.t option;
+        video_channels : VideoChannel.T.t list option;
+        video_languages : string list option;  (** list of languages to filter videos down to *)
+        video_quota : int option;  (** The user video quota in bytes *)
+        video_quota_daily : int option;  (** The user daily video quota in bytes *)
+        videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
+        videos_count : int option;  (** Count of videos published *)
+        abuses_count : int option;  (** Count of reports/abuses of which the user is a target *)
+        abuses_accepted_count : int option;  (** Count of reports/abuses created by the user and accepted/acted upon by the moderation team *)
+        abuses_created_count : int option;  (** Count of reports/abuses created by the user *)
+        video_comments_count : int option;  (** Count of comments published *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      account : Account.T.t option;
-      admin_flags : UserAdminFlags.T.t option;
-      auto_play_next_video : bool option;  (** Automatically start playing the upcoming video after the currently playing video *)
-      auto_play_next_video_playlist : bool option;  (** Automatically start playing the video on the playlist after the currently playing video *)
-      auto_play_video : bool option;  (** Automatically start playing the video on the watch page *)
-      blocked : bool option;
-      blocked_reason : string option;
-      created_at : string option;
-      email : string option;  (** The user email *)
-      email_public : bool option;  (** Has the user accepted to display the email publicly? *)
-      email_verified : bool option;  (** Has the user confirmed their email address? *)
-      id : Id.T.t option;
-      language : string option;  (** default language for this user *)
-      last_login_date : Ptime.t option;
-      new_features_info_read : float option;  (** New features information the user has read *)
-      no_account_setup_warning_modal : bool option;
-      no_instance_config_warning_modal : bool option;
-      no_welcome_modal : bool option;
-      notification_settings : UserNotificationSettings.T.t option;
-      nsfw_flags_blurred : Nsfwflag.T.t option;
-      nsfw_flags_displayed : Nsfwflag.T.t option;
-      nsfw_flags_hidden : Nsfwflag.T.t option;
-      nsfw_flags_warned : Nsfwflag.T.t option;
-      nsfw_policy : Nsfwpolicy.T.t option;
-      p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
-      plugin_auth : string option;  (** Auth plugin to use to authenticate the user *)
-      role : Jsont.json option;
-      theme : string option;  (** Theme enabled by this user *)
-      two_factor_enabled : bool option;  (** Whether the user has enabled two-factor authentication or not *)
-      username : Username.T.t option;
-      video_channels : VideoChannel.T.t list option;
-      video_languages : string list option;  (** list of languages to filter videos down to *)
-      video_quota : int option;  (** The user video quota in bytes *)
-      video_quota_daily : int option;  (** The user daily video quota in bytes *)
-      videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
-      videos_count : int option;  (** Count of videos published *)
-      abuses_count : int option;  (** Count of reports/abuses of which the user is a target *)
-      abuses_accepted_count : int option;  (** Count of reports/abuses created by the user and accepted/acted upon by the moderation team *)
-      abuses_created_count : int option;  (** Count of reports/abuses created by the user *)
-      video_comments_count : int option;  (** Count of comments published *)
-    }
+    include Types.T
     
     let v ?account ?admin_flags ?auto_play_next_video ?auto_play_next_video_playlist ?auto_play_video ?blocked ?blocked_reason ?created_at ?email ?email_public ?email_verified ?id ?language ?last_login_date ?new_features_info_read ?no_account_setup_warning_modal ?no_instance_config_warning_modal ?no_welcome_modal ?notification_settings ?nsfw_flags_blurred ?nsfw_flags_displayed ?nsfw_flags_hidden ?nsfw_flags_warned ?nsfw_policy ?p2p_enabled ?plugin_auth ?role ?theme ?two_factor_enabled ?username ?video_channels ?video_languages ?video_quota ?video_quota_daily ?videos_history_enabled ?videos_count ?abuses_count ?abuses_accepted_count ?abuses_created_count ?video_comments_count () = { account; admin_flags; auto_play_next_video; auto_play_next_video_playlist; auto_play_video; blocked; blocked_reason; created_at; email; email_public; email_verified; id; language; last_login_date; new_features_info_read; no_account_setup_warning_modal; no_instance_config_warning_modal; no_welcome_modal; notification_settings; nsfw_flags_blurred; nsfw_flags_displayed; nsfw_flags_hidden; nsfw_flags_warned; nsfw_policy; p2p_enabled; plugin_auth; role; theme; two_factor_enabled; username; video_channels; video_languages; video_quota; video_quota_daily; videos_history_enabled; videos_count; abuses_count; abuses_accepted_count; abuses_created_count; video_comments_count }
     
···
 end
 
 module User = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        account : Account.T.t option;
+        admin_flags : UserAdminFlags.T.t option;
+        auto_play_next_video : bool option;  (** Automatically start playing the upcoming video after the currently playing video *)
+        auto_play_next_video_playlist : bool option;  (** Automatically start playing the video on the playlist after the currently playing video *)
+        auto_play_video : bool option;  (** Automatically start playing the video on the watch page *)
+        blocked : bool option;
+        blocked_reason : string option;
+        created_at : string option;
+        email : string option;  (** The user email *)
+        email_public : bool option;  (** Has the user accepted to display the email publicly? *)
+        email_verified : bool option;  (** Has the user confirmed their email address? *)
+        id : Id.T.t option;
+        language : string option;  (** default language for this user *)
+        last_login_date : Ptime.t option;
+        new_features_info_read : float option;  (** New features information the user has read *)
+        no_account_setup_warning_modal : bool option;
+        no_instance_config_warning_modal : bool option;
+        no_welcome_modal : bool option;
+        notification_settings : UserNotificationSettings.T.t option;
+        nsfw_flags_blurred : Nsfwflag.T.t option;
+        nsfw_flags_displayed : Nsfwflag.T.t option;
+        nsfw_flags_hidden : Nsfwflag.T.t option;
+        nsfw_flags_warned : Nsfwflag.T.t option;
+        nsfw_policy : Nsfwpolicy.T.t option;
+        p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
+        plugin_auth : string option;  (** Auth plugin to use to authenticate the user *)
+        role : Jsont.json option;
+        theme : string option;  (** Theme enabled by this user *)
+        two_factor_enabled : bool option;  (** Whether the user has enabled two-factor authentication or not *)
+        username : Username.T.t option;
+        video_channels : VideoChannel.T.t list option;
+        video_languages : string list option;  (** list of languages to filter videos down to *)
+        video_quota : int option;  (** The user video quota in bytes *)
+        video_quota_daily : int option;  (** The user daily video quota in bytes *)
+        videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      account : Account.T.t option;
-      admin_flags : UserAdminFlags.T.t option;
-      auto_play_next_video : bool option;  (** Automatically start playing the upcoming video after the currently playing video *)
-      auto_play_next_video_playlist : bool option;  (** Automatically start playing the video on the playlist after the currently playing video *)
-      auto_play_video : bool option;  (** Automatically start playing the video on the watch page *)
-      blocked : bool option;
-      blocked_reason : string option;
-      created_at : string option;
-      email : string option;  (** The user email *)
-      email_public : bool option;  (** Has the user accepted to display the email publicly? *)
-      email_verified : bool option;  (** Has the user confirmed their email address? *)
-      id : Id.T.t option;
-      language : string option;  (** default language for this user *)
-      last_login_date : Ptime.t option;
-      new_features_info_read : float option;  (** New features information the user has read *)
-      no_account_setup_warning_modal : bool option;
-      no_instance_config_warning_modal : bool option;
-      no_welcome_modal : bool option;
-      notification_settings : UserNotificationSettings.T.t option;
-      nsfw_flags_blurred : Nsfwflag.T.t option;
-      nsfw_flags_displayed : Nsfwflag.T.t option;
-      nsfw_flags_hidden : Nsfwflag.T.t option;
-      nsfw_flags_warned : Nsfwflag.T.t option;
-      nsfw_policy : Nsfwpolicy.T.t option;
-      p2p_enabled : bool option;  (** whether to enable P2P in the player or not *)
-      plugin_auth : string option;  (** Auth plugin to use to authenticate the user *)
-      role : Jsont.json option;
-      theme : string option;  (** Theme enabled by this user *)
-      two_factor_enabled : bool option;  (** Whether the user has enabled two-factor authentication or not *)
-      username : Username.T.t option;
-      video_channels : VideoChannel.T.t list option;
-      video_languages : string list option;  (** list of languages to filter videos down to *)
-      video_quota : int option;  (** The user video quota in bytes *)
-      video_quota_daily : int option;  (** The user daily video quota in bytes *)
-      videos_history_enabled : bool option;  (** whether to keep track of watched history or not *)
-    }
+    include Types.T
     
     let v ?account ?admin_flags ?auto_play_next_video ?auto_play_next_video_playlist ?auto_play_video ?blocked ?blocked_reason ?created_at ?email ?email_public ?email_verified ?id ?language ?last_login_date ?new_features_info_read ?no_account_setup_warning_modal ?no_instance_config_warning_modal ?no_welcome_modal ?notification_settings ?nsfw_flags_blurred ?nsfw_flags_displayed ?nsfw_flags_hidden ?nsfw_flags_warned ?nsfw_policy ?p2p_enabled ?plugin_auth ?role ?theme ?two_factor_enabled ?username ?video_channels ?video_languages ?video_quota ?video_quota_daily ?videos_history_enabled () = { account; admin_flags; auto_play_next_video; auto_play_next_video_playlist; auto_play_video; blocked; blocked_reason; created_at; email; email_public; email_verified; id; language; last_login_date; new_features_info_read; no_account_setup_warning_modal; no_instance_config_warning_modal; no_welcome_modal; notification_settings; nsfw_flags_blurred; nsfw_flags_displayed; nsfw_flags_hidden; nsfw_flags_warned; nsfw_policy; p2p_enabled; plugin_auth; role; theme; two_factor_enabled; username; video_channels; video_languages; video_quota; video_quota_daily; videos_history_enabled }
     
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
   
   (** Get my user information *)
···
     if Requests.Response.ok response then
       Openapi.Runtime.Json.decode_json_exn T.jsont (Requests.Response.json response)
     else
+      let body = Requests.Response.text response in
+      let parsed_body =
+        match Jsont_bytesrw.decode_string Jsont.json body with
+        | Ok json -> Some (Openapi.Runtime.Json json)
+        | Error _ -> Some (Openapi.Runtime.Raw body)
+      in
       raise (Openapi.Runtime.Api_error {
         operation = op_name;
         method_ = "GET";
         url;
         status = Requests.Response.status_code response;
-        body = Requests.Response.text response;
+        body;
+        parsed_body;
       })
 end
 
 module AbuseStateSet = struct
+  module Types = struct
+    module T = struct
+      (** The abuse state (Pending = `1`, Rejected = `2`, Accepted = `3`) *)
+      type t = string
+    end
+  end
+  
   module T = struct
-    (** The abuse state (Pending = `1`, Rejected = `2`, Accepted = `3`) *)
-    type t = string
-    
+    include Types.T
     let jsont = Jsont.string
   end
 end
 
 module AbuseStateConstant = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        id : AbuseStateSet.T.t option;
+        label : string option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      id : AbuseStateSet.T.t option;
-      label : string option;
-    }
+    include Types.T
     
     let v ?id ?label () = { id; label }
     
···
 end
 
 module AbusePredefinedReasons = struct
+  module Types = struct
+    module T = struct
+      type t = Jsont.json
+    end
+  end
+  
   module T = struct
-    type t = Jsont.json
-    
+    include Types.T
     let jsont = Jsont.json
-    
     let v () = Jsont.Null ((), Jsont.Meta.none)
   end
 end
 
 module Abuse = struct
+  module Types = struct
+    module T = struct
+      type t = {
+        created_at : Ptime.t option;
+        id : Id.T.t option;
+        moderation_comment : string option;
+        predefined_reasons : AbusePredefinedReasons.T.t option;
+        reason : string option;
+        reporter_account : Account.T.t option;
+        state : AbuseStateConstant.T.t option;
+        video : Jsont.json option;
+      }
+    end
+  end
+  
   module T = struct
-    type t = {
-      created_at : Ptime.t option;
-      id : Id.T.t option;
-      moderation_comment : string option;
-      predefined_reasons : AbusePredefinedReasons.T.t option;
-      reason : string option;
-      reporter_account : Account.T.t option;
-      state : AbuseStateConstant.T.t option;
-      video : Jsont.json option;
-    }
+    include Types.T
     
     let v ?created_at ?id ?moderation_comment ?predefined_reasons ?reason ?reporter_account ?state ?video () = { created_at; id; moderation_comment; predefined_reasons; reason; reporter_account; state; video }
     
···
         (fun created_at id moderation_comment predefined_reasons reason reporter_account state video -> { created_at; id; moderation_comment; predefined_reasons; reason; reporter_account; state; video })
       |> Jsont.Object.opt_mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
       |> Jsont.Object.opt_mem "id" Id.T.jsont ~enc:(fun r -> r.id)
-      |> Jsont.Object.opt_mem "moderationComment" Jsont.string ~enc:(fun r -> r.moderation_comment)
+      |> Jsont.Object.opt_mem "moderationComment" (Openapi.Runtime.validated_string ~min_length:2 ~max_length:3000 Jsont.string) ~enc:(fun r -> r.moderation_comment)
       |> Jsont.Object.opt_mem "predefinedReasons" AbusePredefinedReasons.T.jsont ~enc:(fun r -> r.predefined_reasons)
-      |> Jsont.Object.opt_mem "reason" Jsont.string ~enc:(fun r -> r.reason)
+      |> Jsont.Object.opt_mem "reason" (Openapi.Runtime.validated_string ~min_length:2 ~max_length:3000 Jsont.string) ~enc:(fun r -> r.reason)
       |> Jsont.Object.opt_mem "reporterAccount" Account.T.jsont ~enc:(fun r -> r.reporter_account)
       |> Jsont.Object.opt_mem "state" AbuseStateConstant.T.jsont ~enc:(fun r -> r.state)
       |> Jsont.Object.opt_mem "video" Jsont.json ~enc:(fun r -> r.video)

peertube.mli peer_tube.mli

···
-(** {1 Peertube}
+(** {1 PeerTube}
 
     The PeerTube API is built on HTTP(S) and is RESTful. You can use your favorite
 HTTP/REST library for your programming language to use PeerTube.
···
 
 module VideosForXml : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module VideoStudioCreateTask : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
     
     `0` is used as a special value for stillimage videos dedicated to audio, a.k.a. audio-only videos.
      *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module VideoLicenceSet : sig
   module T : sig
     (** licence id of the video (see [/videos/licences](#operation/getLicences)) *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module VideoLanguageSet : sig
   module T : sig
     (** language id of the video (see [/videos/languages](#operation/getLanguages)) *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module VideoCommentsForXml : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module VideoCategorySet : sig
   module T : sig
     (** category id of the video (see [/videos/categories](#operation/getCategories)) *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module Uuidv4 : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module UsernameChannel : sig
   module T : sig
     (** immutable name of the channel, used to interact with its actor *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module Username : sig
   module T : sig
     (** immutable name of the user, used to find or mention its actor *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module ShortUuid : sig
   module T : sig
     (** translation of a uuid v4 with a bigger alphabet to have a shorter uuid *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module RunnerJobPayload : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 module PredefinedAbuseReasons : sig
   module T : sig
     (** Reason categories that help triage reports *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module Password : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
     - `1` WEB
     - `2` EMAIL
      *)
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module Id : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
 
 module AddVideoPasswords : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t
     
···
     (** Construct a value
         @param text Text of the comment
     *)
-    val v : ?account:Account.T.t -> ?created_at:Ptime.t -> ?deleted_at:Ptime.t -> ?held_for_review:bool -> ?id:Id.T.t -> ?in_reply_to_comment_id:Id.T.t -> ?is_deleted:bool -> ?text:string -> ?thread_id:Id.T.t -> ?total_replies:int -> ?total_replies_from_video_author:int -> ?updated_at:Ptime.t -> ?url:string -> ?video_id:Jsont.json -> unit -> t
+    val v : ?deleted_at:Ptime.t option -> ?is_deleted:bool -> ?account:Account.T.t -> ?created_at:Ptime.t -> ?held_for_review:bool -> ?id:Id.T.t -> ?in_reply_to_comment_id:Id.T.t -> ?text:string -> ?thread_id:Id.T.t -> ?total_replies:int -> ?total_replies_from_video_author:int -> ?updated_at:Ptime.t -> ?url:string -> ?video_id:Jsont.json -> unit -> t
     
     val account : t -> Account.T.t option
     
···
     
     val in_reply_to_comment_id : t -> Id.T.t option
     
-    val is_deleted : t -> bool option
+    val is_deleted : t -> bool
     
     (** Text of the comment *)
     val text : t -> string option
···
 
 module AbusePredefinedReasons : sig
   module T : sig
-    type t
+    type t = Jsont.json
     
     val jsont : t Jsont.t