anil.recoil.org
Immich bindings and CLI in OCaml
1(** {1 Immich}
2
3 Immich API
4
5 @version 2.4.1 *)
6
7type t = {
8 session : Requests.t;
9 base_url : string;
10}
11
12let create ?session ~sw env ~base_url =
13 let session = match session with
14 | Some s -> s
15 | None -> Requests.create ~sw env
16 in
17 { session; base_url }
18
19let base_url t = t.base_url
20let session t = t.session
21
22module WorkflowFilterItem = struct
23 module Types = struct
24 module Dto = struct
25 type t = {
26 filter_config : Jsont.json option;
27 plugin_filter_id : string;
28 }
29 end
30 end
31
32 module Dto = struct
33 include Types.Dto
34
35 let v ~plugin_filter_id ?filter_config () = { filter_config; plugin_filter_id }
36
37 let filter_config t = t.filter_config
38 let plugin_filter_id t = t.plugin_filter_id
39
40 let jsont : t Jsont.t =
41 Jsont.Object.map ~kind:"WorkflowFilterItemDto"
42 (fun filter_config plugin_filter_id -> { filter_config; plugin_filter_id })
43 |> Jsont.Object.opt_mem "filterConfig" Jsont.json ~enc:(fun r -> r.filter_config)
44 |> Jsont.Object.mem "pluginFilterId" Jsont.string ~enc:(fun r -> r.plugin_filter_id)
45 |> Jsont.Object.skip_unknown
46 |> Jsont.Object.finish
47 end
48end
49
50module WorkflowFilter = struct
51 module Types = struct
52 module ResponseDto = struct
53 type t = {
54 filter_config : Jsont.json option;
55 id : string;
56 order : float;
57 plugin_filter_id : string;
58 workflow_id : string;
59 }
60 end
61 end
62
63 module ResponseDto = struct
64 include Types.ResponseDto
65
66 let v ~id ~order ~plugin_filter_id ~workflow_id ?filter_config () = { filter_config; id; order; plugin_filter_id; workflow_id }
67
68 let filter_config t = t.filter_config
69 let id t = t.id
70 let order t = t.order
71 let plugin_filter_id t = t.plugin_filter_id
72 let workflow_id t = t.workflow_id
73
74 let jsont : t Jsont.t =
75 Jsont.Object.map ~kind:"WorkflowFilterResponseDto"
76 (fun filter_config id order plugin_filter_id workflow_id -> { filter_config; id; order; plugin_filter_id; workflow_id })
77 |> Jsont.Object.mem "filterConfig" (Openapi.Runtime.nullable_any Jsont.json)
78 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.filter_config)
79 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
80 |> Jsont.Object.mem "order" Jsont.number ~enc:(fun r -> r.order)
81 |> Jsont.Object.mem "pluginFilterId" Jsont.string ~enc:(fun r -> r.plugin_filter_id)
82 |> Jsont.Object.mem "workflowId" Jsont.string ~enc:(fun r -> r.workflow_id)
83 |> Jsont.Object.skip_unknown
84 |> Jsont.Object.finish
85 end
86end
87
88module WorkflowActionItem = struct
89 module Types = struct
90 module Dto = struct
91 type t = {
92 action_config : Jsont.json option;
93 plugin_action_id : string;
94 }
95 end
96 end
97
98 module Dto = struct
99 include Types.Dto
100
101 let v ~plugin_action_id ?action_config () = { action_config; plugin_action_id }
102
103 let action_config t = t.action_config
104 let plugin_action_id t = t.plugin_action_id
105
106 let jsont : t Jsont.t =
107 Jsont.Object.map ~kind:"WorkflowActionItemDto"
108 (fun action_config plugin_action_id -> { action_config; plugin_action_id })
109 |> Jsont.Object.opt_mem "actionConfig" Jsont.json ~enc:(fun r -> r.action_config)
110 |> Jsont.Object.mem "pluginActionId" Jsont.string ~enc:(fun r -> r.plugin_action_id)
111 |> Jsont.Object.skip_unknown
112 |> Jsont.Object.finish
113 end
114end
115
116module WorkflowAction = struct
117 module Types = struct
118 module ResponseDto = struct
119 type t = {
120 action_config : Jsont.json option;
121 id : string;
122 order : float;
123 plugin_action_id : string;
124 workflow_id : string;
125 }
126 end
127 end
128
129 module ResponseDto = struct
130 include Types.ResponseDto
131
132 let v ~id ~order ~plugin_action_id ~workflow_id ?action_config () = { action_config; id; order; plugin_action_id; workflow_id }
133
134 let action_config t = t.action_config
135 let id t = t.id
136 let order t = t.order
137 let plugin_action_id t = t.plugin_action_id
138 let workflow_id t = t.workflow_id
139
140 let jsont : t Jsont.t =
141 Jsont.Object.map ~kind:"WorkflowActionResponseDto"
142 (fun action_config id order plugin_action_id workflow_id -> { action_config; id; order; plugin_action_id; workflow_id })
143 |> Jsont.Object.mem "actionConfig" (Openapi.Runtime.nullable_any Jsont.json)
144 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.action_config)
145 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
146 |> Jsont.Object.mem "order" Jsont.number ~enc:(fun r -> r.order)
147 |> Jsont.Object.mem "pluginActionId" Jsont.string ~enc:(fun r -> r.plugin_action_id)
148 |> Jsont.Object.mem "workflowId" Jsont.string ~enc:(fun r -> r.workflow_id)
149 |> Jsont.Object.skip_unknown
150 |> Jsont.Object.finish
151 end
152end
153
154module VideoContainer = struct
155 module Types = struct
156 module T = struct
157 type t = [
158 | `Mov
159 | `Mp4
160 | `Ogg
161 | `Webm
162 ]
163 end
164 end
165
166 module T = struct
167 include Types.T
168
169 let jsont : t Jsont.t =
170 Jsont.map Jsont.string ~kind:"VideoContainer"
171 ~dec:(function
172 | "mov" -> `Mov
173 | "mp4" -> `Mp4
174 | "ogg" -> `Ogg
175 | "webm" -> `Webm
176 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
177 ~enc:(function
178 | `Mov -> "mov"
179 | `Mp4 -> "mp4"
180 | `Ogg -> "ogg"
181 | `Webm -> "webm")
182 end
183end
184
185module VideoCodec = struct
186 module Types = struct
187 module T = struct
188 type t = [
189 | `H264
190 | `Hevc
191 | `Vp9
192 | `Av1
193 ]
194 end
195 end
196
197 module T = struct
198 include Types.T
199
200 let jsont : t Jsont.t =
201 Jsont.map Jsont.string ~kind:"VideoCodec"
202 ~dec:(function
203 | "h264" -> `H264
204 | "hevc" -> `Hevc
205 | "vp9" -> `Vp9
206 | "av1" -> `Av1
207 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
208 ~enc:(function
209 | `H264 -> "h264"
210 | `Hevc -> "hevc"
211 | `Vp9 -> "vp9"
212 | `Av1 -> "av1")
213 end
214end
215
216module VersionCheckState = struct
217 module Types = struct
218 module ResponseDto = struct
219 type t = {
220 checked_at : string option;
221 release_version : string option;
222 }
223 end
224 end
225
226 module ResponseDto = struct
227 include Types.ResponseDto
228
229 let v ?checked_at ?release_version () = { checked_at; release_version }
230
231 let checked_at t = t.checked_at
232 let release_version t = t.release_version
233
234 let jsont : t Jsont.t =
235 Jsont.Object.map ~kind:"VersionCheckStateResponseDto"
236 (fun checked_at release_version -> { checked_at; release_version })
237 |> Jsont.Object.mem "checkedAt" Openapi.Runtime.nullable_string
238 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.checked_at)
239 |> Jsont.Object.mem "releaseVersion" Openapi.Runtime.nullable_string
240 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.release_version)
241 |> Jsont.Object.skip_unknown
242 |> Jsont.Object.finish
243 end
244
245 (** Get version check status
246
247 Retrieve information about the last time the version check ran. *)
248 let get_version_check client () =
249 let op_name = "get_version_check" in
250 let url_path = "/server/version-check" in
251 let query = "" in
252 let url = client.base_url ^ url_path ^ query in
253 let response =
254 try Requests.get client.session url
255 with Eio.Io _ as ex ->
256 let bt = Printexc.get_raw_backtrace () in
257 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
258 in
259 if Requests.Response.ok response then
260 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
261 else
262 let body = Requests.Response.text response in
263 let parsed_body =
264 match Jsont_bytesrw.decode_string Jsont.json body with
265 | Ok json -> Some (Openapi.Runtime.Json json)
266 | Error _ -> Some (Openapi.Runtime.Raw body)
267 in
268 raise (Openapi.Runtime.Api_error {
269 operation = op_name;
270 method_ = "GET";
271 url;
272 status = Requests.Response.status_code response;
273 body;
274 parsed_body;
275 })
276
277 (** Retrieve version check state
278
279 Retrieve the current state of the version check process. *)
280 let get_version_check_state client () =
281 let op_name = "get_version_check_state" in
282 let url_path = "/system-metadata/version-check-state" in
283 let query = "" in
284 let url = client.base_url ^ url_path ^ query in
285 let response =
286 try Requests.get client.session url
287 with Eio.Io _ as ex ->
288 let bt = Printexc.get_raw_backtrace () in
289 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
290 in
291 if Requests.Response.ok response then
292 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
293 else
294 let body = Requests.Response.text response in
295 let parsed_body =
296 match Jsont_bytesrw.decode_string Jsont.json body with
297 | Ok json -> Some (Openapi.Runtime.Json json)
298 | Error _ -> Some (Openapi.Runtime.Raw body)
299 in
300 raise (Openapi.Runtime.Api_error {
301 operation = op_name;
302 method_ = "GET";
303 url;
304 status = Requests.Response.status_code response;
305 body;
306 parsed_body;
307 })
308end
309
310module ValidateLibraryImportPath = struct
311 module Types = struct
312 module ResponseDto = struct
313 type t = {
314 import_path : string;
315 is_valid : bool;
316 message : string option;
317 }
318 end
319 end
320
321 module ResponseDto = struct
322 include Types.ResponseDto
323
324 let v ~import_path ?(is_valid=false) ?message () = { import_path; is_valid; message }
325
326 let import_path t = t.import_path
327 let is_valid t = t.is_valid
328 let message t = t.message
329
330 let jsont : t Jsont.t =
331 Jsont.Object.map ~kind:"ValidateLibraryImportPathResponseDto"
332 (fun import_path is_valid message -> { import_path; is_valid; message })
333 |> Jsont.Object.mem "importPath" Jsont.string ~enc:(fun r -> r.import_path)
334 |> Jsont.Object.mem "isValid" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.is_valid)
335 |> Jsont.Object.opt_mem "message" Jsont.string ~enc:(fun r -> r.message)
336 |> Jsont.Object.skip_unknown
337 |> Jsont.Object.finish
338 end
339end
340
341module ValidateLibrary = struct
342 module Types = struct
343 module ResponseDto = struct
344 type t = {
345 import_paths : ValidateLibraryImportPath.ResponseDto.t list option;
346 }
347 end
348
349 module Dto = struct
350 type t = {
351 exclusion_patterns : string list option;
352 import_paths : string list option;
353 }
354 end
355 end
356
357 module ResponseDto = struct
358 include Types.ResponseDto
359
360 let v ?import_paths () = { import_paths }
361
362 let import_paths t = t.import_paths
363
364 let jsont : t Jsont.t =
365 Jsont.Object.map ~kind:"ValidateLibraryResponseDto"
366 (fun import_paths -> { import_paths })
367 |> Jsont.Object.opt_mem "importPaths" (Jsont.list ValidateLibraryImportPath.ResponseDto.jsont) ~enc:(fun r -> r.import_paths)
368 |> Jsont.Object.skip_unknown
369 |> Jsont.Object.finish
370 end
371
372 module Dto = struct
373 include Types.Dto
374
375 let v ?exclusion_patterns ?import_paths () = { exclusion_patterns; import_paths }
376
377 let exclusion_patterns t = t.exclusion_patterns
378 let import_paths t = t.import_paths
379
380 let jsont : t Jsont.t =
381 Jsont.Object.map ~kind:"ValidateLibraryDto"
382 (fun exclusion_patterns import_paths -> { exclusion_patterns; import_paths })
383 |> Jsont.Object.opt_mem "exclusionPatterns" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.exclusion_patterns)
384 |> Jsont.Object.opt_mem "importPaths" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.import_paths)
385 |> Jsont.Object.skip_unknown
386 |> Jsont.Object.finish
387 end
388
389 (** Validate library settings
390
391 Validate the settings of an external library. *)
392 let validate ~id ~body client () =
393 let op_name = "validate" in
394 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}/validate" in
395 let query = "" in
396 let url = client.base_url ^ url_path ^ query in
397 let response =
398 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
399 with Eio.Io _ as ex ->
400 let bt = Printexc.get_raw_backtrace () in
401 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
402 in
403 if Requests.Response.ok response then
404 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
405 else
406 let body = Requests.Response.text response in
407 let parsed_body =
408 match Jsont_bytesrw.decode_string Jsont.json body with
409 | Ok json -> Some (Openapi.Runtime.Json json)
410 | Error _ -> Some (Openapi.Runtime.Raw body)
411 in
412 raise (Openapi.Runtime.Api_error {
413 operation = op_name;
414 method_ = "POST";
415 url;
416 status = Requests.Response.status_code response;
417 body;
418 parsed_body;
419 })
420end
421
422module ValidateAccessToken = struct
423 module Types = struct
424 module ResponseDto = struct
425 type t = {
426 auth_status : bool;
427 }
428 end
429 end
430
431 module ResponseDto = struct
432 include Types.ResponseDto
433
434 let v ~auth_status () = { auth_status }
435
436 let auth_status t = t.auth_status
437
438 let jsont : t Jsont.t =
439 Jsont.Object.map ~kind:"ValidateAccessTokenResponseDto"
440 (fun auth_status -> { auth_status })
441 |> Jsont.Object.mem "authStatus" Jsont.bool ~enc:(fun r -> r.auth_status)
442 |> Jsont.Object.skip_unknown
443 |> Jsont.Object.finish
444 end
445
446 (** Validate access token
447
448 Validate the current authorization method is still valid. *)
449 let validate_access_token client () =
450 let op_name = "validate_access_token" in
451 let url_path = "/auth/validateToken" in
452 let query = "" in
453 let url = client.base_url ^ url_path ^ query in
454 let response =
455 try Requests.post client.session url
456 with Eio.Io _ as ex ->
457 let bt = Printexc.get_raw_backtrace () in
458 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
459 in
460 if Requests.Response.ok response then
461 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
462 else
463 let body = Requests.Response.text response in
464 let parsed_body =
465 match Jsont_bytesrw.decode_string Jsont.json body with
466 | Ok json -> Some (Openapi.Runtime.Json json)
467 | Error _ -> Some (Openapi.Runtime.Raw body)
468 in
469 raise (Openapi.Runtime.Api_error {
470 operation = op_name;
471 method_ = "POST";
472 url;
473 status = Requests.Response.status_code response;
474 body;
475 parsed_body;
476 })
477end
478
479module UserMetadataKey = struct
480 module Types = struct
481 module T = struct
482 type t = [
483 | `Preferences
484 | `License
485 | `Onboarding
486 ]
487 end
488 end
489
490 module T = struct
491 include Types.T
492
493 let jsont : t Jsont.t =
494 Jsont.map Jsont.string ~kind:"UserMetadataKey"
495 ~dec:(function
496 | "preferences" -> `Preferences
497 | "license" -> `License
498 | "onboarding" -> `Onboarding
499 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
500 ~enc:(function
501 | `Preferences -> "preferences"
502 | `License -> "license"
503 | `Onboarding -> "onboarding")
504 end
505end
506
507module SyncUserMetadataV1 = struct
508 module Types = struct
509 module T = struct
510 type t = {
511 key : UserMetadataKey.T.t;
512 user_id : string;
513 value : Jsont.json;
514 }
515 end
516 end
517
518 module T = struct
519 include Types.T
520
521 let v ~key ~user_id ~value () = { key; user_id; value }
522
523 let key t = t.key
524 let user_id t = t.user_id
525 let value t = t.value
526
527 let jsont : t Jsont.t =
528 Jsont.Object.map ~kind:"SyncUserMetadataV1"
529 (fun key user_id value -> { key; user_id; value })
530 |> Jsont.Object.mem "key" UserMetadataKey.T.jsont ~enc:(fun r -> r.key)
531 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
532 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
533 |> Jsont.Object.skip_unknown
534 |> Jsont.Object.finish
535 end
536end
537
538module SyncUserMetadataDeleteV1 = struct
539 module Types = struct
540 module T = struct
541 type t = {
542 key : UserMetadataKey.T.t;
543 user_id : string;
544 }
545 end
546 end
547
548 module T = struct
549 include Types.T
550
551 let v ~key ~user_id () = { key; user_id }
552
553 let key t = t.key
554 let user_id t = t.user_id
555
556 let jsont : t Jsont.t =
557 Jsont.Object.map ~kind:"SyncUserMetadataDeleteV1"
558 (fun key user_id -> { key; user_id })
559 |> Jsont.Object.mem "key" UserMetadataKey.T.jsont ~enc:(fun r -> r.key)
560 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
561 |> Jsont.Object.skip_unknown
562 |> Jsont.Object.finish
563 end
564end
565
566module UserLicense = struct
567 module Types = struct
568 module T = struct
569 type t = {
570 activated_at : Ptime.t;
571 activation_key : string;
572 license_key : string;
573 }
574 end
575 end
576
577 module T = struct
578 include Types.T
579
580 let v ~activated_at ~activation_key ~license_key () = { activated_at; activation_key; license_key }
581
582 let activated_at t = t.activated_at
583 let activation_key t = t.activation_key
584 let license_key t = t.license_key
585
586 let jsont : t Jsont.t =
587 Jsont.Object.map ~kind:"UserLicense"
588 (fun activated_at activation_key license_key -> { activated_at; activation_key; license_key })
589 |> Jsont.Object.mem "activatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.activated_at)
590 |> Jsont.Object.mem "activationKey" Jsont.string ~enc:(fun r -> r.activation_key)
591 |> Jsont.Object.mem "licenseKey" Jsont.string ~enc:(fun r -> r.license_key)
592 |> Jsont.Object.skip_unknown
593 |> Jsont.Object.finish
594 end
595end
596
597module UserAvatarColor = struct
598 module Types = struct
599 module T = struct
600 type t = [
601 | `Primary
602 | `Pink
603 | `Red
604 | `Yellow
605 | `Blue
606 | `Green
607 | `Purple
608 | `Orange
609 | `Gray
610 | `Amber
611 ]
612 end
613 end
614
615 module T = struct
616 include Types.T
617
618 let jsont : t Jsont.t =
619 Jsont.map Jsont.string ~kind:"UserAvatarColor"
620 ~dec:(function
621 | "primary" -> `Primary
622 | "pink" -> `Pink
623 | "red" -> `Red
624 | "yellow" -> `Yellow
625 | "blue" -> `Blue
626 | "green" -> `Green
627 | "purple" -> `Purple
628 | "orange" -> `Orange
629 | "gray" -> `Gray
630 | "amber" -> `Amber
631 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
632 ~enc:(function
633 | `Primary -> "primary"
634 | `Pink -> "pink"
635 | `Red -> "red"
636 | `Yellow -> "yellow"
637 | `Blue -> "blue"
638 | `Green -> "green"
639 | `Purple -> "purple"
640 | `Orange -> "orange"
641 | `Gray -> "gray"
642 | `Amber -> "amber")
643 end
644end
645
646module UserUpdateMe = struct
647 module Types = struct
648 module Dto = struct
649 type t = {
650 avatar_color : UserAvatarColor.T.t option;
651 email : string option;
652 name : string option;
653 password : string option;
654 }
655 end
656 end
657
658 module Dto = struct
659 include Types.Dto
660
661 let v ?avatar_color ?email ?name ?password () = { avatar_color; email; name; password }
662
663 let avatar_color t = t.avatar_color
664 let email t = t.email
665 let name t = t.name
666 let password t = t.password
667
668 let jsont : t Jsont.t =
669 Jsont.Object.map ~kind:"UserUpdateMeDto"
670 (fun avatar_color email name password -> { avatar_color; email; name; password })
671 |> Jsont.Object.opt_mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
672 |> Jsont.Object.opt_mem "email" Jsont.string ~enc:(fun r -> r.email)
673 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
674 |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
675 |> Jsont.Object.skip_unknown
676 |> Jsont.Object.finish
677 end
678end
679
680module User = struct
681 module Types = struct
682 module Status = struct
683 type t = [
684 | `Active
685 | `Removing
686 | `Deleted
687 ]
688 end
689
690 module ResponseDto = struct
691 type t = {
692 avatar_color : UserAvatarColor.T.t;
693 email : string;
694 id : string;
695 name : string;
696 profile_changed_at : Ptime.t;
697 profile_image_path : string;
698 }
699 end
700 end
701
702 module Status = struct
703 include Types.Status
704
705 let jsont : t Jsont.t =
706 Jsont.map Jsont.string ~kind:"UserStatus"
707 ~dec:(function
708 | "active" -> `Active
709 | "removing" -> `Removing
710 | "deleted" -> `Deleted
711 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
712 ~enc:(function
713 | `Active -> "active"
714 | `Removing -> "removing"
715 | `Deleted -> "deleted")
716 end
717
718 module ResponseDto = struct
719 include Types.ResponseDto
720
721 let v ~avatar_color ~email ~id ~name ~profile_changed_at ~profile_image_path () = { avatar_color; email; id; name; profile_changed_at; profile_image_path }
722
723 let avatar_color t = t.avatar_color
724 let email t = t.email
725 let id t = t.id
726 let name t = t.name
727 let profile_changed_at t = t.profile_changed_at
728 let profile_image_path t = t.profile_image_path
729
730 let jsont : t Jsont.t =
731 Jsont.Object.map ~kind:"UserResponseDto"
732 (fun avatar_color email id name profile_changed_at profile_image_path -> { avatar_color; email; id; name; profile_changed_at; profile_image_path })
733 |> Jsont.Object.mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
734 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
735 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
736 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
737 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
738 |> Jsont.Object.mem "profileImagePath" Jsont.string ~enc:(fun r -> r.profile_image_path)
739 |> Jsont.Object.skip_unknown
740 |> Jsont.Object.finish
741 end
742
743 (** Get all users
744
745 Retrieve a list of all users on the server. *)
746 let search_users client () =
747 let op_name = "search_users" in
748 let url_path = "/users" in
749 let query = "" in
750 let url = client.base_url ^ url_path ^ query in
751 let response =
752 try Requests.get client.session url
753 with Eio.Io _ as ex ->
754 let bt = Printexc.get_raw_backtrace () in
755 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
756 in
757 if Requests.Response.ok response then
758 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
759 else
760 let body = Requests.Response.text response in
761 let parsed_body =
762 match Jsont_bytesrw.decode_string Jsont.json body with
763 | Ok json -> Some (Openapi.Runtime.Json json)
764 | Error _ -> Some (Openapi.Runtime.Raw body)
765 in
766 raise (Openapi.Runtime.Api_error {
767 operation = op_name;
768 method_ = "GET";
769 url;
770 status = Requests.Response.status_code response;
771 body;
772 parsed_body;
773 })
774
775 (** Retrieve a user
776
777 Retrieve a specific user by their ID. *)
778 let get_user ~id client () =
779 let op_name = "get_user" in
780 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/users/{id}" in
781 let query = "" in
782 let url = client.base_url ^ url_path ^ query in
783 let response =
784 try Requests.get client.session url
785 with Eio.Io _ as ex ->
786 let bt = Printexc.get_raw_backtrace () in
787 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
788 in
789 if Requests.Response.ok response then
790 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
791 else
792 let body = Requests.Response.text response in
793 let parsed_body =
794 match Jsont_bytesrw.decode_string Jsont.json body with
795 | Ok json -> Some (Openapi.Runtime.Json json)
796 | Error _ -> Some (Openapi.Runtime.Raw body)
797 in
798 raise (Openapi.Runtime.Api_error {
799 operation = op_name;
800 method_ = "GET";
801 url;
802 status = Requests.Response.status_code response;
803 body;
804 parsed_body;
805 })
806end
807
808module SyncUserV1 = struct
809 module Types = struct
810 module T = struct
811 type t = {
812 avatar_color : UserAvatarColor.T.t;
813 deleted_at : Ptime.t option;
814 email : string;
815 has_profile_image : bool;
816 id : string;
817 name : string;
818 profile_changed_at : Ptime.t;
819 }
820 end
821 end
822
823 module T = struct
824 include Types.T
825
826 let v ~avatar_color ~email ~has_profile_image ~id ~name ~profile_changed_at ?deleted_at () = { avatar_color; deleted_at; email; has_profile_image; id; name; profile_changed_at }
827
828 let avatar_color t = t.avatar_color
829 let deleted_at t = t.deleted_at
830 let email t = t.email
831 let has_profile_image t = t.has_profile_image
832 let id t = t.id
833 let name t = t.name
834 let profile_changed_at t = t.profile_changed_at
835
836 let jsont : t Jsont.t =
837 Jsont.Object.map ~kind:"SyncUserV1"
838 (fun avatar_color deleted_at email has_profile_image id name profile_changed_at -> { avatar_color; deleted_at; email; has_profile_image; id; name; profile_changed_at })
839 |> Jsont.Object.mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
840 |> Jsont.Object.mem "deletedAt" Openapi.Runtime.nullable_ptime
841 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.deleted_at)
842 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
843 |> Jsont.Object.mem "hasProfileImage" Jsont.bool ~enc:(fun r -> r.has_profile_image)
844 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
845 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
846 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
847 |> Jsont.Object.skip_unknown
848 |> Jsont.Object.finish
849 end
850end
851
852module SyncAuthUserV1 = struct
853 module Types = struct
854 module T = struct
855 type t = {
856 avatar_color : UserAvatarColor.T.t;
857 deleted_at : Ptime.t option;
858 email : string;
859 has_profile_image : bool;
860 id : string;
861 is_admin : bool;
862 name : string;
863 oauth_id : string;
864 pin_code : string option;
865 profile_changed_at : Ptime.t;
866 quota_size_in_bytes : int option;
867 quota_usage_in_bytes : int;
868 storage_label : string option;
869 }
870 end
871 end
872
873 module T = struct
874 include Types.T
875
876 let v ~avatar_color ~email ~has_profile_image ~id ~is_admin ~name ~oauth_id ~profile_changed_at ~quota_usage_in_bytes ?deleted_at ?pin_code ?quota_size_in_bytes ?storage_label () = { avatar_color; deleted_at; email; has_profile_image; id; is_admin; name; oauth_id; pin_code; profile_changed_at; quota_size_in_bytes; quota_usage_in_bytes; storage_label }
877
878 let avatar_color t = t.avatar_color
879 let deleted_at t = t.deleted_at
880 let email t = t.email
881 let has_profile_image t = t.has_profile_image
882 let id t = t.id
883 let is_admin t = t.is_admin
884 let name t = t.name
885 let oauth_id t = t.oauth_id
886 let pin_code t = t.pin_code
887 let profile_changed_at t = t.profile_changed_at
888 let quota_size_in_bytes t = t.quota_size_in_bytes
889 let quota_usage_in_bytes t = t.quota_usage_in_bytes
890 let storage_label t = t.storage_label
891
892 let jsont : t Jsont.t =
893 Jsont.Object.map ~kind:"SyncAuthUserV1"
894 (fun avatar_color deleted_at email has_profile_image id is_admin name oauth_id pin_code profile_changed_at quota_size_in_bytes quota_usage_in_bytes storage_label -> { avatar_color; deleted_at; email; has_profile_image; id; is_admin; name; oauth_id; pin_code; profile_changed_at; quota_size_in_bytes; quota_usage_in_bytes; storage_label })
895 |> Jsont.Object.mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
896 |> Jsont.Object.mem "deletedAt" Openapi.Runtime.nullable_ptime
897 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.deleted_at)
898 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
899 |> Jsont.Object.mem "hasProfileImage" Jsont.bool ~enc:(fun r -> r.has_profile_image)
900 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
901 |> Jsont.Object.mem "isAdmin" Jsont.bool ~enc:(fun r -> r.is_admin)
902 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
903 |> Jsont.Object.mem "oauthId" Jsont.string ~enc:(fun r -> r.oauth_id)
904 |> Jsont.Object.mem "pinCode" Openapi.Runtime.nullable_string
905 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.pin_code)
906 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
907 |> Jsont.Object.mem "quotaSizeInBytes" Openapi.Runtime.nullable_int
908 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_size_in_bytes)
909 |> Jsont.Object.mem "quotaUsageInBytes" Jsont.int ~enc:(fun r -> r.quota_usage_in_bytes)
910 |> Jsont.Object.mem "storageLabel" Openapi.Runtime.nullable_string
911 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.storage_label)
912 |> Jsont.Object.skip_unknown
913 |> Jsont.Object.finish
914 end
915end
916
917module Partner = struct
918 module Types = struct
919 module UpdateDto = struct
920 type t = {
921 in_timeline : bool;
922 }
923 end
924
925 module ResponseDto = struct
926 type t = {
927 avatar_color : UserAvatarColor.T.t;
928 email : string;
929 id : string;
930 in_timeline : bool option;
931 name : string;
932 profile_changed_at : Ptime.t;
933 profile_image_path : string;
934 }
935 end
936
937 module CreateDto = struct
938 type t = {
939 shared_with_id : string;
940 }
941 end
942 end
943
944 module UpdateDto = struct
945 include Types.UpdateDto
946
947 let v ~in_timeline () = { in_timeline }
948
949 let in_timeline t = t.in_timeline
950
951 let jsont : t Jsont.t =
952 Jsont.Object.map ~kind:"PartnerUpdateDto"
953 (fun in_timeline -> { in_timeline })
954 |> Jsont.Object.mem "inTimeline" Jsont.bool ~enc:(fun r -> r.in_timeline)
955 |> Jsont.Object.skip_unknown
956 |> Jsont.Object.finish
957 end
958
959 module ResponseDto = struct
960 include Types.ResponseDto
961
962 let v ~avatar_color ~email ~id ~name ~profile_changed_at ~profile_image_path ?in_timeline () = { avatar_color; email; id; in_timeline; name; profile_changed_at; profile_image_path }
963
964 let avatar_color t = t.avatar_color
965 let email t = t.email
966 let id t = t.id
967 let in_timeline t = t.in_timeline
968 let name t = t.name
969 let profile_changed_at t = t.profile_changed_at
970 let profile_image_path t = t.profile_image_path
971
972 let jsont : t Jsont.t =
973 Jsont.Object.map ~kind:"PartnerResponseDto"
974 (fun avatar_color email id in_timeline name profile_changed_at profile_image_path -> { avatar_color; email; id; in_timeline; name; profile_changed_at; profile_image_path })
975 |> Jsont.Object.mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
976 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
977 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
978 |> Jsont.Object.opt_mem "inTimeline" Jsont.bool ~enc:(fun r -> r.in_timeline)
979 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
980 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
981 |> Jsont.Object.mem "profileImagePath" Jsont.string ~enc:(fun r -> r.profile_image_path)
982 |> Jsont.Object.skip_unknown
983 |> Jsont.Object.finish
984 end
985
986 module CreateDto = struct
987 include Types.CreateDto
988
989 let v ~shared_with_id () = { shared_with_id }
990
991 let shared_with_id t = t.shared_with_id
992
993 let jsont : t Jsont.t =
994 Jsont.Object.map ~kind:"PartnerCreateDto"
995 (fun shared_with_id -> { shared_with_id })
996 |> Jsont.Object.mem "sharedWithId" Jsont.string ~enc:(fun r -> r.shared_with_id)
997 |> Jsont.Object.skip_unknown
998 |> Jsont.Object.finish
999 end
1000
1001 (** Retrieve partners
1002
1003 Retrieve a list of partners with whom assets are shared. *)
1004 let get_partners ~direction client () =
1005 let op_name = "get_partners" in
1006 let url_path = "/partners" in
1007 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"direction" ~value:direction]) in
1008 let url = client.base_url ^ url_path ^ query in
1009 let response =
1010 try Requests.get client.session url
1011 with Eio.Io _ as ex ->
1012 let bt = Printexc.get_raw_backtrace () in
1013 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
1014 in
1015 if Requests.Response.ok response then
1016 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1017 else
1018 let body = Requests.Response.text response in
1019 let parsed_body =
1020 match Jsont_bytesrw.decode_string Jsont.json body with
1021 | Ok json -> Some (Openapi.Runtime.Json json)
1022 | Error _ -> Some (Openapi.Runtime.Raw body)
1023 in
1024 raise (Openapi.Runtime.Api_error {
1025 operation = op_name;
1026 method_ = "GET";
1027 url;
1028 status = Requests.Response.status_code response;
1029 body;
1030 parsed_body;
1031 })
1032
1033 (** Create a partner
1034
1035 Create a new partner to share assets with. *)
1036 let create_partner ~body client () =
1037 let op_name = "create_partner" in
1038 let url_path = "/partners" in
1039 let query = "" in
1040 let url = client.base_url ^ url_path ^ query in
1041 let response =
1042 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
1043 with Eio.Io _ as ex ->
1044 let bt = Printexc.get_raw_backtrace () in
1045 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
1046 in
1047 if Requests.Response.ok response then
1048 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1049 else
1050 let body = Requests.Response.text response in
1051 let parsed_body =
1052 match Jsont_bytesrw.decode_string Jsont.json body with
1053 | Ok json -> Some (Openapi.Runtime.Json json)
1054 | Error _ -> Some (Openapi.Runtime.Raw body)
1055 in
1056 raise (Openapi.Runtime.Api_error {
1057 operation = op_name;
1058 method_ = "POST";
1059 url;
1060 status = Requests.Response.status_code response;
1061 body;
1062 parsed_body;
1063 })
1064
1065 (** Create a partner
1066
1067 Create a new partner to share assets with. *)
1068 let create_partner_deprecated ~id client () =
1069 let op_name = "create_partner_deprecated" in
1070 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/partners/{id}" in
1071 let query = "" in
1072 let url = client.base_url ^ url_path ^ query in
1073 let response =
1074 try Requests.post client.session url
1075 with Eio.Io _ as ex ->
1076 let bt = Printexc.get_raw_backtrace () in
1077 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
1078 in
1079 if Requests.Response.ok response then
1080 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1081 else
1082 let body = Requests.Response.text response in
1083 let parsed_body =
1084 match Jsont_bytesrw.decode_string Jsont.json body with
1085 | Ok json -> Some (Openapi.Runtime.Json json)
1086 | Error _ -> Some (Openapi.Runtime.Raw body)
1087 in
1088 raise (Openapi.Runtime.Api_error {
1089 operation = op_name;
1090 method_ = "POST";
1091 url;
1092 status = Requests.Response.status_code response;
1093 body;
1094 parsed_body;
1095 })
1096
1097 (** Update a partner
1098
1099 Specify whether a partner's assets should appear in the user's timeline. *)
1100 let update_partner ~id ~body client () =
1101 let op_name = "update_partner" in
1102 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/partners/{id}" in
1103 let query = "" in
1104 let url = client.base_url ^ url_path ^ query in
1105 let response =
1106 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
1107 with Eio.Io _ as ex ->
1108 let bt = Printexc.get_raw_backtrace () in
1109 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
1110 in
1111 if Requests.Response.ok response then
1112 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1113 else
1114 let body = Requests.Response.text response in
1115 let parsed_body =
1116 match Jsont_bytesrw.decode_string Jsont.json body with
1117 | Ok json -> Some (Openapi.Runtime.Json json)
1118 | Error _ -> Some (Openapi.Runtime.Raw body)
1119 in
1120 raise (Openapi.Runtime.Api_error {
1121 operation = op_name;
1122 method_ = "PUT";
1123 url;
1124 status = Requests.Response.status_code response;
1125 body;
1126 parsed_body;
1127 })
1128end
1129
1130module Avatar = struct
1131 module Types = struct
1132 module Update = struct
1133 type t = {
1134 color : UserAvatarColor.T.t option;
1135 }
1136 end
1137 end
1138
1139 module Update = struct
1140 include Types.Update
1141
1142 let v ?color () = { color }
1143
1144 let color t = t.color
1145
1146 let jsont : t Jsont.t =
1147 Jsont.Object.map ~kind:"AvatarUpdate"
1148 (fun color -> { color })
1149 |> Jsont.Object.opt_mem "color" UserAvatarColor.T.jsont ~enc:(fun r -> r.color)
1150 |> Jsont.Object.skip_unknown
1151 |> Jsont.Object.finish
1152 end
1153end
1154
1155module UserAdminDelete = struct
1156 module Types = struct
1157 module Dto = struct
1158 type t = {
1159 force : bool option;
1160 }
1161 end
1162 end
1163
1164 module Dto = struct
1165 include Types.Dto
1166
1167 let v ?force () = { force }
1168
1169 let force t = t.force
1170
1171 let jsont : t Jsont.t =
1172 Jsont.Object.map ~kind:"UserAdminDeleteDto"
1173 (fun force -> { force })
1174 |> Jsont.Object.opt_mem "force" Jsont.bool ~enc:(fun r -> r.force)
1175 |> Jsont.Object.skip_unknown
1176 |> Jsont.Object.finish
1177 end
1178end
1179
1180module UsageByUser = struct
1181 module Types = struct
1182 module Dto = struct
1183 type t = {
1184 photos : int;
1185 quota_size_in_bytes : int64 option;
1186 usage : int64;
1187 usage_photos : int64;
1188 usage_videos : int64;
1189 user_id : string;
1190 user_name : string;
1191 videos : int;
1192 }
1193 end
1194 end
1195
1196 module Dto = struct
1197 include Types.Dto
1198
1199 let v ~photos ~usage ~usage_photos ~usage_videos ~user_id ~user_name ~videos ?quota_size_in_bytes () = { photos; quota_size_in_bytes; usage; usage_photos; usage_videos; user_id; user_name; videos }
1200
1201 let photos t = t.photos
1202 let quota_size_in_bytes t = t.quota_size_in_bytes
1203 let usage t = t.usage
1204 let usage_photos t = t.usage_photos
1205 let usage_videos t = t.usage_videos
1206 let user_id t = t.user_id
1207 let user_name t = t.user_name
1208 let videos t = t.videos
1209
1210 let jsont : t Jsont.t =
1211 Jsont.Object.map ~kind:"UsageByUserDto"
1212 (fun photos quota_size_in_bytes usage usage_photos usage_videos user_id user_name videos -> { photos; quota_size_in_bytes; usage; usage_photos; usage_videos; user_id; user_name; videos })
1213 |> Jsont.Object.mem "photos" Jsont.int ~enc:(fun r -> r.photos)
1214 |> Jsont.Object.mem "quotaSizeInBytes" (Openapi.Runtime.nullable_any Jsont.int64)
1215 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_size_in_bytes)
1216 |> Jsont.Object.mem "usage" Jsont.int64 ~enc:(fun r -> r.usage)
1217 |> Jsont.Object.mem "usagePhotos" Jsont.int64 ~enc:(fun r -> r.usage_photos)
1218 |> Jsont.Object.mem "usageVideos" Jsont.int64 ~enc:(fun r -> r.usage_videos)
1219 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
1220 |> Jsont.Object.mem "userName" Jsont.string ~enc:(fun r -> r.user_name)
1221 |> Jsont.Object.mem "videos" Jsont.int ~enc:(fun r -> r.videos)
1222 |> Jsont.Object.skip_unknown
1223 |> Jsont.Object.finish
1224 end
1225end
1226
1227module ServerStats = struct
1228 module Types = struct
1229 module ResponseDto = struct
1230 type t = {
1231 photos : int;
1232 usage : int64;
1233 usage_by_user : UsageByUser.Dto.t list;
1234 usage_photos : int64;
1235 usage_videos : int64;
1236 videos : int;
1237 }
1238 end
1239 end
1240
1241 module ResponseDto = struct
1242 include Types.ResponseDto
1243
1244 let v ?(photos=0) ?(usage=0L) ?(usage_by_user=[]) ?(usage_photos=0L) ?(usage_videos=0L) ?(videos=0) () = { photos; usage; usage_by_user; usage_photos; usage_videos; videos }
1245
1246 let photos t = t.photos
1247 let usage t = t.usage
1248 let usage_by_user t = t.usage_by_user
1249 let usage_photos t = t.usage_photos
1250 let usage_videos t = t.usage_videos
1251 let videos t = t.videos
1252
1253 let jsont : t Jsont.t =
1254 Jsont.Object.map ~kind:"ServerStatsResponseDto"
1255 (fun photos usage usage_by_user usage_photos usage_videos videos -> { photos; usage; usage_by_user; usage_photos; usage_videos; videos })
1256 |> Jsont.Object.mem "photos" Jsont.int ~dec_absent:0 ~enc:(fun r -> r.photos)
1257 |> Jsont.Object.mem "usage" Jsont.int64 ~dec_absent:0L ~enc:(fun r -> r.usage)
1258 |> Jsont.Object.mem "usageByUser" (Jsont.list UsageByUser.Dto.jsont) ~dec_absent:[] ~enc:(fun r -> r.usage_by_user)
1259 |> Jsont.Object.mem "usagePhotos" Jsont.int64 ~dec_absent:0L ~enc:(fun r -> r.usage_photos)
1260 |> Jsont.Object.mem "usageVideos" Jsont.int64 ~dec_absent:0L ~enc:(fun r -> r.usage_videos)
1261 |> Jsont.Object.mem "videos" Jsont.int ~dec_absent:0 ~enc:(fun r -> r.videos)
1262 |> Jsont.Object.skip_unknown
1263 |> Jsont.Object.finish
1264 end
1265
1266 (** Get statistics
1267
1268 Retrieve statistics about the entire Immich instance such as asset counts. *)
1269 let get_server_statistics client () =
1270 let op_name = "get_server_statistics" in
1271 let url_path = "/server/statistics" in
1272 let query = "" in
1273 let url = client.base_url ^ url_path ^ query in
1274 let response =
1275 try Requests.get client.session url
1276 with Eio.Io _ as ex ->
1277 let bt = Printexc.get_raw_backtrace () in
1278 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
1279 in
1280 if Requests.Response.ok response then
1281 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1282 else
1283 let body = Requests.Response.text response in
1284 let parsed_body =
1285 match Jsont_bytesrw.decode_string Jsont.json body with
1286 | Ok json -> Some (Openapi.Runtime.Json json)
1287 | Error _ -> Some (Openapi.Runtime.Raw body)
1288 in
1289 raise (Openapi.Runtime.Api_error {
1290 operation = op_name;
1291 method_ = "GET";
1292 url;
1293 status = Requests.Response.status_code response;
1294 body;
1295 parsed_body;
1296 })
1297end
1298
1299module UpdateLibrary = struct
1300 module Types = struct
1301 module Dto = struct
1302 type t = {
1303 exclusion_patterns : string list option;
1304 import_paths : string list option;
1305 name : string option;
1306 }
1307 end
1308 end
1309
1310 module Dto = struct
1311 include Types.Dto
1312
1313 let v ?exclusion_patterns ?import_paths ?name () = { exclusion_patterns; import_paths; name }
1314
1315 let exclusion_patterns t = t.exclusion_patterns
1316 let import_paths t = t.import_paths
1317 let name t = t.name
1318
1319 let jsont : t Jsont.t =
1320 Jsont.Object.map ~kind:"UpdateLibraryDto"
1321 (fun exclusion_patterns import_paths name -> { exclusion_patterns; import_paths; name })
1322 |> Jsont.Object.opt_mem "exclusionPatterns" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.exclusion_patterns)
1323 |> Jsont.Object.opt_mem "importPaths" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.import_paths)
1324 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
1325 |> Jsont.Object.skip_unknown
1326 |> Jsont.Object.finish
1327 end
1328end
1329
1330module TranscodePolicy = struct
1331 module Types = struct
1332 module T = struct
1333 type t = [
1334 | `All
1335 | `Optimal
1336 | `Bitrate
1337 | `Required
1338 | `Disabled
1339 ]
1340 end
1341 end
1342
1343 module T = struct
1344 include Types.T
1345
1346 let jsont : t Jsont.t =
1347 Jsont.map Jsont.string ~kind:"TranscodePolicy"
1348 ~dec:(function
1349 | "all" -> `All
1350 | "optimal" -> `Optimal
1351 | "bitrate" -> `Bitrate
1352 | "required" -> `Required
1353 | "disabled" -> `Disabled
1354 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
1355 ~enc:(function
1356 | `All -> "all"
1357 | `Optimal -> "optimal"
1358 | `Bitrate -> "bitrate"
1359 | `Required -> "required"
1360 | `Disabled -> "disabled")
1361 end
1362end
1363
1364module TranscodeHwaccel = struct
1365 module Types = struct
1366 module T = struct
1367 type t = [
1368 | `Nvenc
1369 | `Qsv
1370 | `Vaapi
1371 | `Rkmpp
1372 | `Disabled
1373 ]
1374 end
1375 end
1376
1377 module T = struct
1378 include Types.T
1379
1380 let jsont : t Jsont.t =
1381 Jsont.map Jsont.string ~kind:"TranscodeHWAccel"
1382 ~dec:(function
1383 | "nvenc" -> `Nvenc
1384 | "qsv" -> `Qsv
1385 | "vaapi" -> `Vaapi
1386 | "rkmpp" -> `Rkmpp
1387 | "disabled" -> `Disabled
1388 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
1389 ~enc:(function
1390 | `Nvenc -> "nvenc"
1391 | `Qsv -> "qsv"
1392 | `Vaapi -> "vaapi"
1393 | `Rkmpp -> "rkmpp"
1394 | `Disabled -> "disabled")
1395 end
1396end
1397
1398module ToneMapping = struct
1399 module Types = struct
1400 module T = struct
1401 type t = [
1402 | `Hable
1403 | `Mobius
1404 | `Reinhard
1405 | `Disabled
1406 ]
1407 end
1408 end
1409
1410 module T = struct
1411 include Types.T
1412
1413 let jsont : t Jsont.t =
1414 Jsont.map Jsont.string ~kind:"ToneMapping"
1415 ~dec:(function
1416 | "hable" -> `Hable
1417 | "mobius" -> `Mobius
1418 | "reinhard" -> `Reinhard
1419 | "disabled" -> `Disabled
1420 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
1421 ~enc:(function
1422 | `Hable -> "hable"
1423 | `Mobius -> "mobius"
1424 | `Reinhard -> "reinhard"
1425 | `Disabled -> "disabled")
1426 end
1427end
1428
1429module TimeBuckets = struct
1430 module Types = struct
1431 module ResponseDto = struct
1432 type t = {
1433 count : int; (** Number of assets in this time bucket *)
1434 time_bucket : string; (** Time bucket identifier in YYYY-MM-DD format representing the start of the time period *)
1435 }
1436 end
1437 end
1438
1439 module ResponseDto = struct
1440 include Types.ResponseDto
1441
1442 let v ~count ~time_bucket () = { count; time_bucket }
1443
1444 let count t = t.count
1445 let time_bucket t = t.time_bucket
1446
1447 let jsont : t Jsont.t =
1448 Jsont.Object.map ~kind:"TimeBucketsResponseDto"
1449 (fun count time_bucket -> { count; time_bucket })
1450 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
1451 |> Jsont.Object.mem "timeBucket" Jsont.string ~enc:(fun r -> r.time_bucket)
1452 |> Jsont.Object.skip_unknown
1453 |> Jsont.Object.finish
1454 end
1455
1456 (** Get time buckets
1457
1458 Retrieve a list of all minimal time buckets.
1459 @param album_id Filter assets belonging to a specific album
1460 @param is_favorite Filter by favorite status (true for favorites only, false for non-favorites only)
1461 @param is_trashed Filter by trash status (true for trashed assets only, false for non-trashed only)
1462 @param order Sort order for assets within time buckets (ASC for oldest first, DESC for newest first)
1463 @param person_id Filter assets containing a specific person (face recognition)
1464 @param tag_id Filter assets with a specific tag
1465 @param user_id Filter assets by specific user ID
1466 @param visibility Filter by asset visibility status (ARCHIVE, TIMELINE, HIDDEN, LOCKED)
1467 @param with_coordinates Include location data in the response
1468 @param with_partners Include assets shared by partners
1469 @param with_stacked Include stacked assets in the response. When true, only primary assets from stacks are returned.
1470 *)
1471 let get_time_buckets ?album_id ?is_favorite ?is_trashed ?key ?order ?person_id ?slug ?tag_id ?user_id ?visibility ?with_coordinates ?with_partners ?with_stacked client () =
1472 let op_name = "get_time_buckets" in
1473 let url_path = "/timeline/buckets" in
1474 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"albumId" ~value:album_id; Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"order" ~value:order; Openapi.Runtime.Query.optional ~key:"personId" ~value:person_id; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug; Openapi.Runtime.Query.optional ~key:"tagId" ~value:tag_id; Openapi.Runtime.Query.optional ~key:"userId" ~value:user_id; Openapi.Runtime.Query.optional ~key:"visibility" ~value:visibility; Openapi.Runtime.Query.optional ~key:"withCoordinates" ~value:with_coordinates; Openapi.Runtime.Query.optional ~key:"withPartners" ~value:with_partners; Openapi.Runtime.Query.optional ~key:"withStacked" ~value:with_stacked]) in
1475 let url = client.base_url ^ url_path ^ query in
1476 let response =
1477 try Requests.get client.session url
1478 with Eio.Io _ as ex ->
1479 let bt = Printexc.get_raw_backtrace () in
1480 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
1481 in
1482 if Requests.Response.ok response then
1483 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1484 else
1485 let body = Requests.Response.text response in
1486 let parsed_body =
1487 match Jsont_bytesrw.decode_string Jsont.json body with
1488 | Ok json -> Some (Openapi.Runtime.Json json)
1489 | Error _ -> Some (Openapi.Runtime.Raw body)
1490 in
1491 raise (Openapi.Runtime.Api_error {
1492 operation = op_name;
1493 method_ = "GET";
1494 url;
1495 status = Requests.Response.status_code response;
1496 body;
1497 parsed_body;
1498 })
1499end
1500
1501module Template = struct
1502 module Types = struct
1503 module ResponseDto = struct
1504 type t = {
1505 html : string;
1506 name : string;
1507 }
1508 end
1509
1510 module Dto = struct
1511 type t = {
1512 template : string;
1513 }
1514 end
1515 end
1516
1517 module ResponseDto = struct
1518 include Types.ResponseDto
1519
1520 let v ~html ~name () = { html; name }
1521
1522 let html t = t.html
1523 let name t = t.name
1524
1525 let jsont : t Jsont.t =
1526 Jsont.Object.map ~kind:"TemplateResponseDto"
1527 (fun html name -> { html; name })
1528 |> Jsont.Object.mem "html" Jsont.string ~enc:(fun r -> r.html)
1529 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
1530 |> Jsont.Object.skip_unknown
1531 |> Jsont.Object.finish
1532 end
1533
1534 module Dto = struct
1535 include Types.Dto
1536
1537 let v ~template () = { template }
1538
1539 let template t = t.template
1540
1541 let jsont : t Jsont.t =
1542 Jsont.Object.map ~kind:"TemplateDto"
1543 (fun template -> { template })
1544 |> Jsont.Object.mem "template" Jsont.string ~enc:(fun r -> r.template)
1545 |> Jsont.Object.skip_unknown
1546 |> Jsont.Object.finish
1547 end
1548
1549 (** Render email template
1550
1551 Retrieve a preview of the provided email template. *)
1552 let get_notification_template_admin ~name ~body client () =
1553 let op_name = "get_notification_template_admin" in
1554 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/admin/notifications/templates/{name}" in
1555 let query = "" in
1556 let url = client.base_url ^ url_path ^ query in
1557 let response =
1558 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
1559 with Eio.Io _ as ex ->
1560 let bt = Printexc.get_raw_backtrace () in
1561 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
1562 in
1563 if Requests.Response.ok response then
1564 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1565 else
1566 let body = Requests.Response.text response in
1567 let parsed_body =
1568 match Jsont_bytesrw.decode_string Jsont.json body with
1569 | Ok json -> Some (Openapi.Runtime.Json json)
1570 | Error _ -> Some (Openapi.Runtime.Raw body)
1571 in
1572 raise (Openapi.Runtime.Api_error {
1573 operation = op_name;
1574 method_ = "POST";
1575 url;
1576 status = Requests.Response.status_code response;
1577 body;
1578 parsed_body;
1579 })
1580end
1581
1582module Tags = struct
1583 module Types = struct
1584 module Update = struct
1585 type t = {
1586 enabled : bool option;
1587 sidebar_web : bool option;
1588 }
1589 end
1590
1591 module Response = struct
1592 type t = {
1593 enabled : bool;
1594 sidebar_web : bool;
1595 }
1596 end
1597 end
1598
1599 module Update = struct
1600 include Types.Update
1601
1602 let v ?enabled ?sidebar_web () = { enabled; sidebar_web }
1603
1604 let enabled t = t.enabled
1605 let sidebar_web t = t.sidebar_web
1606
1607 let jsont : t Jsont.t =
1608 Jsont.Object.map ~kind:"TagsUpdate"
1609 (fun enabled sidebar_web -> { enabled; sidebar_web })
1610 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
1611 |> Jsont.Object.opt_mem "sidebarWeb" Jsont.bool ~enc:(fun r -> r.sidebar_web)
1612 |> Jsont.Object.skip_unknown
1613 |> Jsont.Object.finish
1614 end
1615
1616 module Response = struct
1617 include Types.Response
1618
1619 let v ?(enabled=true) ?(sidebar_web=true) () = { enabled; sidebar_web }
1620
1621 let enabled t = t.enabled
1622 let sidebar_web t = t.sidebar_web
1623
1624 let jsont : t Jsont.t =
1625 Jsont.Object.map ~kind:"TagsResponse"
1626 (fun enabled sidebar_web -> { enabled; sidebar_web })
1627 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.enabled)
1628 |> Jsont.Object.mem "sidebarWeb" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.sidebar_web)
1629 |> Jsont.Object.skip_unknown
1630 |> Jsont.Object.finish
1631 end
1632end
1633
1634module TagUpsert = struct
1635 module Types = struct
1636 module Dto = struct
1637 type t = {
1638 tags : string list;
1639 }
1640 end
1641 end
1642
1643 module Dto = struct
1644 include Types.Dto
1645
1646 let v ~tags () = { tags }
1647
1648 let tags t = t.tags
1649
1650 let jsont : t Jsont.t =
1651 Jsont.Object.map ~kind:"TagUpsertDto"
1652 (fun tags -> { tags })
1653 |> Jsont.Object.mem "tags" (Jsont.list Jsont.string) ~enc:(fun r -> r.tags)
1654 |> Jsont.Object.skip_unknown
1655 |> Jsont.Object.finish
1656 end
1657end
1658
1659module Tag = struct
1660 module Types = struct
1661 module UpdateDto = struct
1662 type t = {
1663 color : string option;
1664 }
1665 end
1666
1667 module ResponseDto = struct
1668 type t = {
1669 color : string option;
1670 created_at : Ptime.t;
1671 id : string;
1672 name : string;
1673 parent_id : string option;
1674 updated_at : Ptime.t;
1675 value : string;
1676 }
1677 end
1678
1679 module CreateDto = struct
1680 type t = {
1681 color : string option;
1682 name : string;
1683 parent_id : string option;
1684 }
1685 end
1686 end
1687
1688 module UpdateDto = struct
1689 include Types.UpdateDto
1690
1691 let v ?color () = { color }
1692
1693 let color t = t.color
1694
1695 let jsont : t Jsont.t =
1696 Jsont.Object.map ~kind:"TagUpdateDto"
1697 (fun color -> { color })
1698 |> Jsont.Object.mem "color" Openapi.Runtime.nullable_string
1699 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.color)
1700 |> Jsont.Object.skip_unknown
1701 |> Jsont.Object.finish
1702 end
1703
1704 module ResponseDto = struct
1705 include Types.ResponseDto
1706
1707 let v ~created_at ~id ~name ~updated_at ~value ?color ?parent_id () = { color; created_at; id; name; parent_id; updated_at; value }
1708
1709 let color t = t.color
1710 let created_at t = t.created_at
1711 let id t = t.id
1712 let name t = t.name
1713 let parent_id t = t.parent_id
1714 let updated_at t = t.updated_at
1715 let value t = t.value
1716
1717 let jsont : t Jsont.t =
1718 Jsont.Object.map ~kind:"TagResponseDto"
1719 (fun color created_at id name parent_id updated_at value -> { color; created_at; id; name; parent_id; updated_at; value })
1720 |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
1721 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
1722 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
1723 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
1724 |> Jsont.Object.opt_mem "parentId" Jsont.string ~enc:(fun r -> r.parent_id)
1725 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
1726 |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
1727 |> Jsont.Object.skip_unknown
1728 |> Jsont.Object.finish
1729 end
1730
1731 module CreateDto = struct
1732 include Types.CreateDto
1733
1734 let v ~name ?color ?parent_id () = { color; name; parent_id }
1735
1736 let color t = t.color
1737 let name t = t.name
1738 let parent_id t = t.parent_id
1739
1740 let jsont : t Jsont.t =
1741 Jsont.Object.map ~kind:"TagCreateDto"
1742 (fun color name parent_id -> { color; name; parent_id })
1743 |> Jsont.Object.opt_mem "color" (Openapi.Runtime.validated_string ~pattern:"^#?([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$" Jsont.string) ~enc:(fun r -> r.color)
1744 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
1745 |> Jsont.Object.mem "parentId" Openapi.Runtime.nullable_string
1746 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.parent_id)
1747 |> Jsont.Object.skip_unknown
1748 |> Jsont.Object.finish
1749 end
1750
1751 (** Retrieve tags
1752
1753 Retrieve a list of all tags. *)
1754 let get_all_tags client () =
1755 let op_name = "get_all_tags" in
1756 let url_path = "/tags" in
1757 let query = "" in
1758 let url = client.base_url ^ url_path ^ query in
1759 let response =
1760 try Requests.get client.session url
1761 with Eio.Io _ as ex ->
1762 let bt = Printexc.get_raw_backtrace () in
1763 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
1764 in
1765 if Requests.Response.ok response then
1766 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1767 else
1768 let body = Requests.Response.text response in
1769 let parsed_body =
1770 match Jsont_bytesrw.decode_string Jsont.json body with
1771 | Ok json -> Some (Openapi.Runtime.Json json)
1772 | Error _ -> Some (Openapi.Runtime.Raw body)
1773 in
1774 raise (Openapi.Runtime.Api_error {
1775 operation = op_name;
1776 method_ = "GET";
1777 url;
1778 status = Requests.Response.status_code response;
1779 body;
1780 parsed_body;
1781 })
1782
1783 (** Create a tag
1784
1785 Create a new tag by providing a name and optional color. *)
1786 let create_tag ~body client () =
1787 let op_name = "create_tag" in
1788 let url_path = "/tags" in
1789 let query = "" in
1790 let url = client.base_url ^ url_path ^ query in
1791 let response =
1792 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
1793 with Eio.Io _ as ex ->
1794 let bt = Printexc.get_raw_backtrace () in
1795 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
1796 in
1797 if Requests.Response.ok response then
1798 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1799 else
1800 let body = Requests.Response.text response in
1801 let parsed_body =
1802 match Jsont_bytesrw.decode_string Jsont.json body with
1803 | Ok json -> Some (Openapi.Runtime.Json json)
1804 | Error _ -> Some (Openapi.Runtime.Raw body)
1805 in
1806 raise (Openapi.Runtime.Api_error {
1807 operation = op_name;
1808 method_ = "POST";
1809 url;
1810 status = Requests.Response.status_code response;
1811 body;
1812 parsed_body;
1813 })
1814
1815 (** Upsert tags
1816
1817 Create or update multiple tags in a single request. *)
1818 let upsert_tags ~body client () =
1819 let op_name = "upsert_tags" in
1820 let url_path = "/tags" in
1821 let query = "" in
1822 let url = client.base_url ^ url_path ^ query in
1823 let response =
1824 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json TagUpsert.Dto.jsont body)) url
1825 with Eio.Io _ as ex ->
1826 let bt = Printexc.get_raw_backtrace () in
1827 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
1828 in
1829 if Requests.Response.ok response then
1830 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1831 else
1832 let body = Requests.Response.text response in
1833 let parsed_body =
1834 match Jsont_bytesrw.decode_string Jsont.json body with
1835 | Ok json -> Some (Openapi.Runtime.Json json)
1836 | Error _ -> Some (Openapi.Runtime.Raw body)
1837 in
1838 raise (Openapi.Runtime.Api_error {
1839 operation = op_name;
1840 method_ = "PUT";
1841 url;
1842 status = Requests.Response.status_code response;
1843 body;
1844 parsed_body;
1845 })
1846
1847 (** Retrieve a tag
1848
1849 Retrieve a specific tag by its ID. *)
1850 let get_tag_by_id ~id client () =
1851 let op_name = "get_tag_by_id" in
1852 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/tags/{id}" in
1853 let query = "" in
1854 let url = client.base_url ^ url_path ^ query in
1855 let response =
1856 try Requests.get client.session url
1857 with Eio.Io _ as ex ->
1858 let bt = Printexc.get_raw_backtrace () in
1859 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
1860 in
1861 if Requests.Response.ok response then
1862 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1863 else
1864 let body = Requests.Response.text response in
1865 let parsed_body =
1866 match Jsont_bytesrw.decode_string Jsont.json body with
1867 | Ok json -> Some (Openapi.Runtime.Json json)
1868 | Error _ -> Some (Openapi.Runtime.Raw body)
1869 in
1870 raise (Openapi.Runtime.Api_error {
1871 operation = op_name;
1872 method_ = "GET";
1873 url;
1874 status = Requests.Response.status_code response;
1875 body;
1876 parsed_body;
1877 })
1878
1879 (** Update a tag
1880
1881 Update an existing tag identified by its ID. *)
1882 let update_tag ~id ~body client () =
1883 let op_name = "update_tag" in
1884 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/tags/{id}" in
1885 let query = "" in
1886 let url = client.base_url ^ url_path ^ query in
1887 let response =
1888 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
1889 with Eio.Io _ as ex ->
1890 let bt = Printexc.get_raw_backtrace () in
1891 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
1892 in
1893 if Requests.Response.ok response then
1894 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1895 else
1896 let body = Requests.Response.text response in
1897 let parsed_body =
1898 match Jsont_bytesrw.decode_string Jsont.json body with
1899 | Ok json -> Some (Openapi.Runtime.Json json)
1900 | Error _ -> Some (Openapi.Runtime.Raw body)
1901 in
1902 raise (Openapi.Runtime.Api_error {
1903 operation = op_name;
1904 method_ = "PUT";
1905 url;
1906 status = Requests.Response.status_code response;
1907 body;
1908 parsed_body;
1909 })
1910end
1911
1912module TagBulkAssets = struct
1913 module Types = struct
1914 module ResponseDto = struct
1915 type t = {
1916 count : int;
1917 }
1918 end
1919
1920 module Dto = struct
1921 type t = {
1922 asset_ids : string list;
1923 tag_ids : string list;
1924 }
1925 end
1926 end
1927
1928 module ResponseDto = struct
1929 include Types.ResponseDto
1930
1931 let v ~count () = { count }
1932
1933 let count t = t.count
1934
1935 let jsont : t Jsont.t =
1936 Jsont.Object.map ~kind:"TagBulkAssetsResponseDto"
1937 (fun count -> { count })
1938 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
1939 |> Jsont.Object.skip_unknown
1940 |> Jsont.Object.finish
1941 end
1942
1943 module Dto = struct
1944 include Types.Dto
1945
1946 let v ~asset_ids ~tag_ids () = { asset_ids; tag_ids }
1947
1948 let asset_ids t = t.asset_ids
1949 let tag_ids t = t.tag_ids
1950
1951 let jsont : t Jsont.t =
1952 Jsont.Object.map ~kind:"TagBulkAssetsDto"
1953 (fun asset_ids tag_ids -> { asset_ids; tag_ids })
1954 |> Jsont.Object.mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
1955 |> Jsont.Object.mem "tagIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.tag_ids)
1956 |> Jsont.Object.skip_unknown
1957 |> Jsont.Object.finish
1958 end
1959
1960 (** Tag assets
1961
1962 Add multiple tags to multiple assets in a single request. *)
1963 let bulk_tag_assets ~body client () =
1964 let op_name = "bulk_tag_assets" in
1965 let url_path = "/tags/assets" in
1966 let query = "" in
1967 let url = client.base_url ^ url_path ^ query in
1968 let response =
1969 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
1970 with Eio.Io _ as ex ->
1971 let bt = Printexc.get_raw_backtrace () in
1972 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
1973 in
1974 if Requests.Response.ok response then
1975 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
1976 else
1977 let body = Requests.Response.text response in
1978 let parsed_body =
1979 match Jsont_bytesrw.decode_string Jsont.json body with
1980 | Ok json -> Some (Openapi.Runtime.Json json)
1981 | Error _ -> Some (Openapi.Runtime.Raw body)
1982 in
1983 raise (Openapi.Runtime.Api_error {
1984 operation = op_name;
1985 method_ = "PUT";
1986 url;
1987 status = Requests.Response.status_code response;
1988 body;
1989 parsed_body;
1990 })
1991end
1992
1993module SystemConfigUser = struct
1994 module Types = struct
1995 module Dto = struct
1996 type t = {
1997 delete_delay : int;
1998 }
1999 end
2000 end
2001
2002 module Dto = struct
2003 include Types.Dto
2004
2005 let v ~delete_delay () = { delete_delay }
2006
2007 let delete_delay t = t.delete_delay
2008
2009 let jsont : t Jsont.t =
2010 Jsont.Object.map ~kind:"SystemConfigUserDto"
2011 (fun delete_delay -> { delete_delay })
2012 |> Jsont.Object.mem "deleteDelay" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.delete_delay)
2013 |> Jsont.Object.skip_unknown
2014 |> Jsont.Object.finish
2015 end
2016end
2017
2018module SystemConfigTrash = struct
2019 module Types = struct
2020 module Dto = struct
2021 type t = {
2022 days : int;
2023 enabled : bool;
2024 }
2025 end
2026 end
2027
2028 module Dto = struct
2029 include Types.Dto
2030
2031 let v ~days ~enabled () = { days; enabled }
2032
2033 let days t = t.days
2034 let enabled t = t.enabled
2035
2036 let jsont : t Jsont.t =
2037 Jsont.Object.map ~kind:"SystemConfigTrashDto"
2038 (fun days enabled -> { days; enabled })
2039 |> Jsont.Object.mem "days" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.days)
2040 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2041 |> Jsont.Object.skip_unknown
2042 |> Jsont.Object.finish
2043 end
2044end
2045
2046module SystemConfigTheme = struct
2047 module Types = struct
2048 module Dto = struct
2049 type t = {
2050 custom_css : string;
2051 }
2052 end
2053 end
2054
2055 module Dto = struct
2056 include Types.Dto
2057
2058 let v ~custom_css () = { custom_css }
2059
2060 let custom_css t = t.custom_css
2061
2062 let jsont : t Jsont.t =
2063 Jsont.Object.map ~kind:"SystemConfigThemeDto"
2064 (fun custom_css -> { custom_css })
2065 |> Jsont.Object.mem "customCss" Jsont.string ~enc:(fun r -> r.custom_css)
2066 |> Jsont.Object.skip_unknown
2067 |> Jsont.Object.finish
2068 end
2069end
2070
2071module SystemConfigTemplateStorageOption = struct
2072 module Types = struct
2073 module Dto = struct
2074 type t = {
2075 day_options : string list;
2076 hour_options : string list;
2077 minute_options : string list;
2078 month_options : string list;
2079 preset_options : string list;
2080 second_options : string list;
2081 week_options : string list;
2082 year_options : string list;
2083 }
2084 end
2085 end
2086
2087 module Dto = struct
2088 include Types.Dto
2089
2090 let v ~day_options ~hour_options ~minute_options ~month_options ~preset_options ~second_options ~week_options ~year_options () = { day_options; hour_options; minute_options; month_options; preset_options; second_options; week_options; year_options }
2091
2092 let day_options t = t.day_options
2093 let hour_options t = t.hour_options
2094 let minute_options t = t.minute_options
2095 let month_options t = t.month_options
2096 let preset_options t = t.preset_options
2097 let second_options t = t.second_options
2098 let week_options t = t.week_options
2099 let year_options t = t.year_options
2100
2101 let jsont : t Jsont.t =
2102 Jsont.Object.map ~kind:"SystemConfigTemplateStorageOptionDto"
2103 (fun day_options hour_options minute_options month_options preset_options second_options week_options year_options -> { day_options; hour_options; minute_options; month_options; preset_options; second_options; week_options; year_options })
2104 |> Jsont.Object.mem "dayOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.day_options)
2105 |> Jsont.Object.mem "hourOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.hour_options)
2106 |> Jsont.Object.mem "minuteOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.minute_options)
2107 |> Jsont.Object.mem "monthOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.month_options)
2108 |> Jsont.Object.mem "presetOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.preset_options)
2109 |> Jsont.Object.mem "secondOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.second_options)
2110 |> Jsont.Object.mem "weekOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.week_options)
2111 |> Jsont.Object.mem "yearOptions" (Jsont.list Jsont.string) ~enc:(fun r -> r.year_options)
2112 |> Jsont.Object.skip_unknown
2113 |> Jsont.Object.finish
2114 end
2115
2116 (** Get storage template options
2117
2118 Retrieve exemplary storage template options. *)
2119 let get_storage_template_options client () =
2120 let op_name = "get_storage_template_options" in
2121 let url_path = "/system-config/storage-template-options" in
2122 let query = "" in
2123 let url = client.base_url ^ url_path ^ query in
2124 let response =
2125 try Requests.get client.session url
2126 with Eio.Io _ as ex ->
2127 let bt = Printexc.get_raw_backtrace () in
2128 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
2129 in
2130 if Requests.Response.ok response then
2131 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
2132 else
2133 let body = Requests.Response.text response in
2134 let parsed_body =
2135 match Jsont_bytesrw.decode_string Jsont.json body with
2136 | Ok json -> Some (Openapi.Runtime.Json json)
2137 | Error _ -> Some (Openapi.Runtime.Raw body)
2138 in
2139 raise (Openapi.Runtime.Api_error {
2140 operation = op_name;
2141 method_ = "GET";
2142 url;
2143 status = Requests.Response.status_code response;
2144 body;
2145 parsed_body;
2146 })
2147end
2148
2149module SystemConfigTemplateEmails = struct
2150 module Types = struct
2151 module Dto = struct
2152 type t = {
2153 album_invite_template : string;
2154 album_update_template : string;
2155 welcome_template : string;
2156 }
2157 end
2158 end
2159
2160 module Dto = struct
2161 include Types.Dto
2162
2163 let v ~album_invite_template ~album_update_template ~welcome_template () = { album_invite_template; album_update_template; welcome_template }
2164
2165 let album_invite_template t = t.album_invite_template
2166 let album_update_template t = t.album_update_template
2167 let welcome_template t = t.welcome_template
2168
2169 let jsont : t Jsont.t =
2170 Jsont.Object.map ~kind:"SystemConfigTemplateEmailsDto"
2171 (fun album_invite_template album_update_template welcome_template -> { album_invite_template; album_update_template; welcome_template })
2172 |> Jsont.Object.mem "albumInviteTemplate" Jsont.string ~enc:(fun r -> r.album_invite_template)
2173 |> Jsont.Object.mem "albumUpdateTemplate" Jsont.string ~enc:(fun r -> r.album_update_template)
2174 |> Jsont.Object.mem "welcomeTemplate" Jsont.string ~enc:(fun r -> r.welcome_template)
2175 |> Jsont.Object.skip_unknown
2176 |> Jsont.Object.finish
2177 end
2178end
2179
2180module SystemConfigTemplates = struct
2181 module Types = struct
2182 module Dto = struct
2183 type t = {
2184 email : SystemConfigTemplateEmails.Dto.t;
2185 }
2186 end
2187 end
2188
2189 module Dto = struct
2190 include Types.Dto
2191
2192 let v ~email () = { email }
2193
2194 let email t = t.email
2195
2196 let jsont : t Jsont.t =
2197 Jsont.Object.map ~kind:"SystemConfigTemplatesDto"
2198 (fun email -> { email })
2199 |> Jsont.Object.mem "email" SystemConfigTemplateEmails.Dto.jsont ~enc:(fun r -> r.email)
2200 |> Jsont.Object.skip_unknown
2201 |> Jsont.Object.finish
2202 end
2203end
2204
2205module SystemConfigStorageTemplate = struct
2206 module Types = struct
2207 module Dto = struct
2208 type t = {
2209 enabled : bool;
2210 hash_verification_enabled : bool;
2211 template : string;
2212 }
2213 end
2214 end
2215
2216 module Dto = struct
2217 include Types.Dto
2218
2219 let v ~enabled ~hash_verification_enabled ~template () = { enabled; hash_verification_enabled; template }
2220
2221 let enabled t = t.enabled
2222 let hash_verification_enabled t = t.hash_verification_enabled
2223 let template t = t.template
2224
2225 let jsont : t Jsont.t =
2226 Jsont.Object.map ~kind:"SystemConfigStorageTemplateDto"
2227 (fun enabled hash_verification_enabled template -> { enabled; hash_verification_enabled; template })
2228 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2229 |> Jsont.Object.mem "hashVerificationEnabled" Jsont.bool ~enc:(fun r -> r.hash_verification_enabled)
2230 |> Jsont.Object.mem "template" Jsont.string ~enc:(fun r -> r.template)
2231 |> Jsont.Object.skip_unknown
2232 |> Jsont.Object.finish
2233 end
2234end
2235
2236module SystemConfigSmtpTransport = struct
2237 module Types = struct
2238 module Dto = struct
2239 type t = {
2240 host : string;
2241 ignore_cert : bool;
2242 password : string;
2243 port : float;
2244 secure : bool;
2245 username : string;
2246 }
2247 end
2248 end
2249
2250 module Dto = struct
2251 include Types.Dto
2252
2253 let v ~host ~ignore_cert ~password ~port ~secure ~username () = { host; ignore_cert; password; port; secure; username }
2254
2255 let host t = t.host
2256 let ignore_cert t = t.ignore_cert
2257 let password t = t.password
2258 let port t = t.port
2259 let secure t = t.secure
2260 let username t = t.username
2261
2262 let jsont : t Jsont.t =
2263 Jsont.Object.map ~kind:"SystemConfigSmtpTransportDto"
2264 (fun host ignore_cert password port secure username -> { host; ignore_cert; password; port; secure; username })
2265 |> Jsont.Object.mem "host" Jsont.string ~enc:(fun r -> r.host)
2266 |> Jsont.Object.mem "ignoreCert" Jsont.bool ~enc:(fun r -> r.ignore_cert)
2267 |> Jsont.Object.mem "password" Jsont.string ~enc:(fun r -> r.password)
2268 |> Jsont.Object.mem "port" (Openapi.Runtime.validated_float ~minimum:0. ~maximum:65535. Jsont.number) ~enc:(fun r -> r.port)
2269 |> Jsont.Object.mem "secure" Jsont.bool ~enc:(fun r -> r.secure)
2270 |> Jsont.Object.mem "username" Jsont.string ~enc:(fun r -> r.username)
2271 |> Jsont.Object.skip_unknown
2272 |> Jsont.Object.finish
2273 end
2274end
2275
2276module SystemConfigSmtp = struct
2277 module Types = struct
2278 module Dto = struct
2279 type t = {
2280 enabled : bool;
2281 from : string;
2282 reply_to : string;
2283 transport : SystemConfigSmtpTransport.Dto.t;
2284 }
2285 end
2286 end
2287
2288 module Dto = struct
2289 include Types.Dto
2290
2291 let v ~enabled ~from ~reply_to ~transport () = { enabled; from; reply_to; transport }
2292
2293 let enabled t = t.enabled
2294 let from t = t.from
2295 let reply_to t = t.reply_to
2296 let transport t = t.transport
2297
2298 let jsont : t Jsont.t =
2299 Jsont.Object.map ~kind:"SystemConfigSmtpDto"
2300 (fun enabled from reply_to transport -> { enabled; from; reply_to; transport })
2301 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2302 |> Jsont.Object.mem "from" Jsont.string ~enc:(fun r -> r.from)
2303 |> Jsont.Object.mem "replyTo" Jsont.string ~enc:(fun r -> r.reply_to)
2304 |> Jsont.Object.mem "transport" SystemConfigSmtpTransport.Dto.jsont ~enc:(fun r -> r.transport)
2305 |> Jsont.Object.skip_unknown
2306 |> Jsont.Object.finish
2307 end
2308end
2309
2310module TestEmail = struct
2311 module Types = struct
2312 module ResponseDto = struct
2313 type t = {
2314 message_id : string;
2315 }
2316 end
2317 end
2318
2319 module ResponseDto = struct
2320 include Types.ResponseDto
2321
2322 let v ~message_id () = { message_id }
2323
2324 let message_id t = t.message_id
2325
2326 let jsont : t Jsont.t =
2327 Jsont.Object.map ~kind:"TestEmailResponseDto"
2328 (fun message_id -> { message_id })
2329 |> Jsont.Object.mem "messageId" Jsont.string ~enc:(fun r -> r.message_id)
2330 |> Jsont.Object.skip_unknown
2331 |> Jsont.Object.finish
2332 end
2333
2334 (** Send test email
2335
2336 Send a test email using the provided SMTP configuration. *)
2337 let send_test_email_admin ~body client () =
2338 let op_name = "send_test_email_admin" in
2339 let url_path = "/admin/notifications/test-email" in
2340 let query = "" in
2341 let url = client.base_url ^ url_path ^ query in
2342 let response =
2343 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SystemConfigSmtp.Dto.jsont body)) url
2344 with Eio.Io _ as ex ->
2345 let bt = Printexc.get_raw_backtrace () in
2346 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
2347 in
2348 if Requests.Response.ok response then
2349 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
2350 else
2351 let body = Requests.Response.text response in
2352 let parsed_body =
2353 match Jsont_bytesrw.decode_string Jsont.json body with
2354 | Ok json -> Some (Openapi.Runtime.Json json)
2355 | Error _ -> Some (Openapi.Runtime.Raw body)
2356 in
2357 raise (Openapi.Runtime.Api_error {
2358 operation = op_name;
2359 method_ = "POST";
2360 url;
2361 status = Requests.Response.status_code response;
2362 body;
2363 parsed_body;
2364 })
2365end
2366
2367module SystemConfigNotifications = struct
2368 module Types = struct
2369 module Dto = struct
2370 type t = {
2371 smtp : SystemConfigSmtp.Dto.t;
2372 }
2373 end
2374 end
2375
2376 module Dto = struct
2377 include Types.Dto
2378
2379 let v ~smtp () = { smtp }
2380
2381 let smtp t = t.smtp
2382
2383 let jsont : t Jsont.t =
2384 Jsont.Object.map ~kind:"SystemConfigNotificationsDto"
2385 (fun smtp -> { smtp })
2386 |> Jsont.Object.mem "smtp" SystemConfigSmtp.Dto.jsont ~enc:(fun r -> r.smtp)
2387 |> Jsont.Object.skip_unknown
2388 |> Jsont.Object.finish
2389 end
2390end
2391
2392module SystemConfigServer = struct
2393 module Types = struct
2394 module Dto = struct
2395 type t = {
2396 external_domain : string;
2397 login_page_message : string;
2398 public_users : bool;
2399 }
2400 end
2401 end
2402
2403 module Dto = struct
2404 include Types.Dto
2405
2406 let v ~external_domain ~login_page_message ~public_users () = { external_domain; login_page_message; public_users }
2407
2408 let external_domain t = t.external_domain
2409 let login_page_message t = t.login_page_message
2410 let public_users t = t.public_users
2411
2412 let jsont : t Jsont.t =
2413 Jsont.Object.map ~kind:"SystemConfigServerDto"
2414 (fun external_domain login_page_message public_users -> { external_domain; login_page_message; public_users })
2415 |> Jsont.Object.mem "externalDomain" Jsont.string ~enc:(fun r -> r.external_domain)
2416 |> Jsont.Object.mem "loginPageMessage" Jsont.string ~enc:(fun r -> r.login_page_message)
2417 |> Jsont.Object.mem "publicUsers" Jsont.bool ~enc:(fun r -> r.public_users)
2418 |> Jsont.Object.skip_unknown
2419 |> Jsont.Object.finish
2420 end
2421end
2422
2423module SystemConfigReverseGeocoding = struct
2424 module Types = struct
2425 module Dto = struct
2426 type t = {
2427 enabled : bool;
2428 }
2429 end
2430 end
2431
2432 module Dto = struct
2433 include Types.Dto
2434
2435 let v ~enabled () = { enabled }
2436
2437 let enabled t = t.enabled
2438
2439 let jsont : t Jsont.t =
2440 Jsont.Object.map ~kind:"SystemConfigReverseGeocodingDto"
2441 (fun enabled -> { enabled })
2442 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2443 |> Jsont.Object.skip_unknown
2444 |> Jsont.Object.finish
2445 end
2446end
2447
2448module SystemConfigPasswordLogin = struct
2449 module Types = struct
2450 module Dto = struct
2451 type t = {
2452 enabled : bool;
2453 }
2454 end
2455 end
2456
2457 module Dto = struct
2458 include Types.Dto
2459
2460 let v ~enabled () = { enabled }
2461
2462 let enabled t = t.enabled
2463
2464 let jsont : t Jsont.t =
2465 Jsont.Object.map ~kind:"SystemConfigPasswordLoginDto"
2466 (fun enabled -> { enabled })
2467 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2468 |> Jsont.Object.skip_unknown
2469 |> Jsont.Object.finish
2470 end
2471end
2472
2473module SystemConfigNightlyTasks = struct
2474 module Types = struct
2475 module Dto = struct
2476 type t = {
2477 cluster_new_faces : bool;
2478 database_cleanup : bool;
2479 generate_memories : bool;
2480 missing_thumbnails : bool;
2481 start_time : string;
2482 sync_quota_usage : bool;
2483 }
2484 end
2485 end
2486
2487 module Dto = struct
2488 include Types.Dto
2489
2490 let v ~cluster_new_faces ~database_cleanup ~generate_memories ~missing_thumbnails ~start_time ~sync_quota_usage () = { cluster_new_faces; database_cleanup; generate_memories; missing_thumbnails; start_time; sync_quota_usage }
2491
2492 let cluster_new_faces t = t.cluster_new_faces
2493 let database_cleanup t = t.database_cleanup
2494 let generate_memories t = t.generate_memories
2495 let missing_thumbnails t = t.missing_thumbnails
2496 let start_time t = t.start_time
2497 let sync_quota_usage t = t.sync_quota_usage
2498
2499 let jsont : t Jsont.t =
2500 Jsont.Object.map ~kind:"SystemConfigNightlyTasksDto"
2501 (fun cluster_new_faces database_cleanup generate_memories missing_thumbnails start_time sync_quota_usage -> { cluster_new_faces; database_cleanup; generate_memories; missing_thumbnails; start_time; sync_quota_usage })
2502 |> Jsont.Object.mem "clusterNewFaces" Jsont.bool ~enc:(fun r -> r.cluster_new_faces)
2503 |> Jsont.Object.mem "databaseCleanup" Jsont.bool ~enc:(fun r -> r.database_cleanup)
2504 |> Jsont.Object.mem "generateMemories" Jsont.bool ~enc:(fun r -> r.generate_memories)
2505 |> Jsont.Object.mem "missingThumbnails" Jsont.bool ~enc:(fun r -> r.missing_thumbnails)
2506 |> Jsont.Object.mem "startTime" Jsont.string ~enc:(fun r -> r.start_time)
2507 |> Jsont.Object.mem "syncQuotaUsage" Jsont.bool ~enc:(fun r -> r.sync_quota_usage)
2508 |> Jsont.Object.skip_unknown
2509 |> Jsont.Object.finish
2510 end
2511end
2512
2513module SystemConfigNewVersionCheck = struct
2514 module Types = struct
2515 module Dto = struct
2516 type t = {
2517 enabled : bool;
2518 }
2519 end
2520 end
2521
2522 module Dto = struct
2523 include Types.Dto
2524
2525 let v ~enabled () = { enabled }
2526
2527 let enabled t = t.enabled
2528
2529 let jsont : t Jsont.t =
2530 Jsont.Object.map ~kind:"SystemConfigNewVersionCheckDto"
2531 (fun enabled -> { enabled })
2532 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2533 |> Jsont.Object.skip_unknown
2534 |> Jsont.Object.finish
2535 end
2536end
2537
2538module SystemConfigMap = struct
2539 module Types = struct
2540 module Dto = struct
2541 type t = {
2542 dark_style : string;
2543 enabled : bool;
2544 light_style : string;
2545 }
2546 end
2547 end
2548
2549 module Dto = struct
2550 include Types.Dto
2551
2552 let v ~dark_style ~enabled ~light_style () = { dark_style; enabled; light_style }
2553
2554 let dark_style t = t.dark_style
2555 let enabled t = t.enabled
2556 let light_style t = t.light_style
2557
2558 let jsont : t Jsont.t =
2559 Jsont.Object.map ~kind:"SystemConfigMapDto"
2560 (fun dark_style enabled light_style -> { dark_style; enabled; light_style })
2561 |> Jsont.Object.mem "darkStyle" Jsont.string ~enc:(fun r -> r.dark_style)
2562 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2563 |> Jsont.Object.mem "lightStyle" Jsont.string ~enc:(fun r -> r.light_style)
2564 |> Jsont.Object.skip_unknown
2565 |> Jsont.Object.finish
2566 end
2567end
2568
2569module SystemConfigLibraryWatch = struct
2570 module Types = struct
2571 module Dto = struct
2572 type t = {
2573 enabled : bool;
2574 }
2575 end
2576 end
2577
2578 module Dto = struct
2579 include Types.Dto
2580
2581 let v ~enabled () = { enabled }
2582
2583 let enabled t = t.enabled
2584
2585 let jsont : t Jsont.t =
2586 Jsont.Object.map ~kind:"SystemConfigLibraryWatchDto"
2587 (fun enabled -> { enabled })
2588 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2589 |> Jsont.Object.skip_unknown
2590 |> Jsont.Object.finish
2591 end
2592end
2593
2594module SystemConfigLibraryScan = struct
2595 module Types = struct
2596 module Dto = struct
2597 type t = {
2598 cron_expression : string;
2599 enabled : bool;
2600 }
2601 end
2602 end
2603
2604 module Dto = struct
2605 include Types.Dto
2606
2607 let v ~cron_expression ~enabled () = { cron_expression; enabled }
2608
2609 let cron_expression t = t.cron_expression
2610 let enabled t = t.enabled
2611
2612 let jsont : t Jsont.t =
2613 Jsont.Object.map ~kind:"SystemConfigLibraryScanDto"
2614 (fun cron_expression enabled -> { cron_expression; enabled })
2615 |> Jsont.Object.mem "cronExpression" Jsont.string ~enc:(fun r -> r.cron_expression)
2616 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
2617 |> Jsont.Object.skip_unknown
2618 |> Jsont.Object.finish
2619 end
2620end
2621
2622module SystemConfigLibrary = struct
2623 module Types = struct
2624 module Dto = struct
2625 type t = {
2626 scan : SystemConfigLibraryScan.Dto.t;
2627 watch : SystemConfigLibraryWatch.Dto.t;
2628 }
2629 end
2630 end
2631
2632 module Dto = struct
2633 include Types.Dto
2634
2635 let v ~scan ~watch () = { scan; watch }
2636
2637 let scan t = t.scan
2638 let watch t = t.watch
2639
2640 let jsont : t Jsont.t =
2641 Jsont.Object.map ~kind:"SystemConfigLibraryDto"
2642 (fun scan watch -> { scan; watch })
2643 |> Jsont.Object.mem "scan" SystemConfigLibraryScan.Dto.jsont ~enc:(fun r -> r.scan)
2644 |> Jsont.Object.mem "watch" SystemConfigLibraryWatch.Dto.jsont ~enc:(fun r -> r.watch)
2645 |> Jsont.Object.skip_unknown
2646 |> Jsont.Object.finish
2647 end
2648end
2649
2650module SystemConfigFaces = struct
2651 module Types = struct
2652 module Dto = struct
2653 type t = {
2654 import : bool;
2655 }
2656 end
2657 end
2658
2659 module Dto = struct
2660 include Types.Dto
2661
2662 let v ~import () = { import }
2663
2664 let import t = t.import
2665
2666 let jsont : t Jsont.t =
2667 Jsont.Object.map ~kind:"SystemConfigFacesDto"
2668 (fun import -> { import })
2669 |> Jsont.Object.mem "import" Jsont.bool ~enc:(fun r -> r.import)
2670 |> Jsont.Object.skip_unknown
2671 |> Jsont.Object.finish
2672 end
2673end
2674
2675module SystemConfigMetadata = struct
2676 module Types = struct
2677 module Dto = struct
2678 type t = {
2679 faces : SystemConfigFaces.Dto.t;
2680 }
2681 end
2682 end
2683
2684 module Dto = struct
2685 include Types.Dto
2686
2687 let v ~faces () = { faces }
2688
2689 let faces t = t.faces
2690
2691 let jsont : t Jsont.t =
2692 Jsont.Object.map ~kind:"SystemConfigMetadataDto"
2693 (fun faces -> { faces })
2694 |> Jsont.Object.mem "faces" SystemConfigFaces.Dto.jsont ~enc:(fun r -> r.faces)
2695 |> Jsont.Object.skip_unknown
2696 |> Jsont.Object.finish
2697 end
2698end
2699
2700module SyncUserDeleteV1 = struct
2701 module Types = struct
2702 module T = struct
2703 type t = {
2704 user_id : string;
2705 }
2706 end
2707 end
2708
2709 module T = struct
2710 include Types.T
2711
2712 let v ~user_id () = { user_id }
2713
2714 let user_id t = t.user_id
2715
2716 let jsont : t Jsont.t =
2717 Jsont.Object.map ~kind:"SyncUserDeleteV1"
2718 (fun user_id -> { user_id })
2719 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
2720 |> Jsont.Object.skip_unknown
2721 |> Jsont.Object.finish
2722 end
2723end
2724
2725module SyncStackV1 = struct
2726 module Types = struct
2727 module T = struct
2728 type t = {
2729 created_at : Ptime.t;
2730 id : string;
2731 owner_id : string;
2732 primary_asset_id : string;
2733 updated_at : Ptime.t;
2734 }
2735 end
2736 end
2737
2738 module T = struct
2739 include Types.T
2740
2741 let v ~created_at ~id ~owner_id ~primary_asset_id ~updated_at () = { created_at; id; owner_id; primary_asset_id; updated_at }
2742
2743 let created_at t = t.created_at
2744 let id t = t.id
2745 let owner_id t = t.owner_id
2746 let primary_asset_id t = t.primary_asset_id
2747 let updated_at t = t.updated_at
2748
2749 let jsont : t Jsont.t =
2750 Jsont.Object.map ~kind:"SyncStackV1"
2751 (fun created_at id owner_id primary_asset_id updated_at -> { created_at; id; owner_id; primary_asset_id; updated_at })
2752 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
2753 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
2754 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
2755 |> Jsont.Object.mem "primaryAssetId" Jsont.string ~enc:(fun r -> r.primary_asset_id)
2756 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
2757 |> Jsont.Object.skip_unknown
2758 |> Jsont.Object.finish
2759 end
2760end
2761
2762module SyncStackDeleteV1 = struct
2763 module Types = struct
2764 module T = struct
2765 type t = {
2766 stack_id : string;
2767 }
2768 end
2769 end
2770
2771 module T = struct
2772 include Types.T
2773
2774 let v ~stack_id () = { stack_id }
2775
2776 let stack_id t = t.stack_id
2777
2778 let jsont : t Jsont.t =
2779 Jsont.Object.map ~kind:"SyncStackDeleteV1"
2780 (fun stack_id -> { stack_id })
2781 |> Jsont.Object.mem "stackId" Jsont.string ~enc:(fun r -> r.stack_id)
2782 |> Jsont.Object.skip_unknown
2783 |> Jsont.Object.finish
2784 end
2785end
2786
2787module SyncResetV1 = struct
2788 module Types = struct
2789 module T = struct
2790 type t = Jsont.json
2791 end
2792 end
2793
2794 module T = struct
2795 include Types.T
2796 let jsont = Jsont.json
2797 let v () = Jsont.Null ((), Jsont.Meta.none)
2798 end
2799end
2800
2801module SyncRequest = struct
2802 module Types = struct
2803 module Type = struct
2804 type t = [
2805 | `Albums_v1
2806 | `Album_users_v1
2807 | `Album_to_assets_v1
2808 | `Album_assets_v1
2809 | `Album_asset_exifs_v1
2810 | `Assets_v1
2811 | `Asset_exifs_v1
2812 | `Asset_metadata_v1
2813 | `Auth_users_v1
2814 | `Memories_v1
2815 | `Memory_to_assets_v1
2816 | `Partners_v1
2817 | `Partner_assets_v1
2818 | `Partner_asset_exifs_v1
2819 | `Partner_stacks_v1
2820 | `Stacks_v1
2821 | `Users_v1
2822 | `People_v1
2823 | `Asset_faces_v1
2824 | `User_metadata_v1
2825 ]
2826 end
2827 end
2828
2829 module Type = struct
2830 include Types.Type
2831
2832 let jsont : t Jsont.t =
2833 Jsont.map Jsont.string ~kind:"SyncRequestType"
2834 ~dec:(function
2835 | "AlbumsV1" -> `Albums_v1
2836 | "AlbumUsersV1" -> `Album_users_v1
2837 | "AlbumToAssetsV1" -> `Album_to_assets_v1
2838 | "AlbumAssetsV1" -> `Album_assets_v1
2839 | "AlbumAssetExifsV1" -> `Album_asset_exifs_v1
2840 | "AssetsV1" -> `Assets_v1
2841 | "AssetExifsV1" -> `Asset_exifs_v1
2842 | "AssetMetadataV1" -> `Asset_metadata_v1
2843 | "AuthUsersV1" -> `Auth_users_v1
2844 | "MemoriesV1" -> `Memories_v1
2845 | "MemoryToAssetsV1" -> `Memory_to_assets_v1
2846 | "PartnersV1" -> `Partners_v1
2847 | "PartnerAssetsV1" -> `Partner_assets_v1
2848 | "PartnerAssetExifsV1" -> `Partner_asset_exifs_v1
2849 | "PartnerStacksV1" -> `Partner_stacks_v1
2850 | "StacksV1" -> `Stacks_v1
2851 | "UsersV1" -> `Users_v1
2852 | "PeopleV1" -> `People_v1
2853 | "AssetFacesV1" -> `Asset_faces_v1
2854 | "UserMetadataV1" -> `User_metadata_v1
2855 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
2856 ~enc:(function
2857 | `Albums_v1 -> "AlbumsV1"
2858 | `Album_users_v1 -> "AlbumUsersV1"
2859 | `Album_to_assets_v1 -> "AlbumToAssetsV1"
2860 | `Album_assets_v1 -> "AlbumAssetsV1"
2861 | `Album_asset_exifs_v1 -> "AlbumAssetExifsV1"
2862 | `Assets_v1 -> "AssetsV1"
2863 | `Asset_exifs_v1 -> "AssetExifsV1"
2864 | `Asset_metadata_v1 -> "AssetMetadataV1"
2865 | `Auth_users_v1 -> "AuthUsersV1"
2866 | `Memories_v1 -> "MemoriesV1"
2867 | `Memory_to_assets_v1 -> "MemoryToAssetsV1"
2868 | `Partners_v1 -> "PartnersV1"
2869 | `Partner_assets_v1 -> "PartnerAssetsV1"
2870 | `Partner_asset_exifs_v1 -> "PartnerAssetExifsV1"
2871 | `Partner_stacks_v1 -> "PartnerStacksV1"
2872 | `Stacks_v1 -> "StacksV1"
2873 | `Users_v1 -> "UsersV1"
2874 | `People_v1 -> "PeopleV1"
2875 | `Asset_faces_v1 -> "AssetFacesV1"
2876 | `User_metadata_v1 -> "UserMetadataV1")
2877 end
2878end
2879
2880module SyncStream = struct
2881 module Types = struct
2882 module Dto = struct
2883 type t = {
2884 reset : bool option;
2885 types : SyncRequest.Type.t list;
2886 }
2887 end
2888 end
2889
2890 module Dto = struct
2891 include Types.Dto
2892
2893 let v ~types ?reset () = { reset; types }
2894
2895 let reset t = t.reset
2896 let types t = t.types
2897
2898 let jsont : t Jsont.t =
2899 Jsont.Object.map ~kind:"SyncStreamDto"
2900 (fun reset types -> { reset; types })
2901 |> Jsont.Object.opt_mem "reset" Jsont.bool ~enc:(fun r -> r.reset)
2902 |> Jsont.Object.mem "types" (Jsont.list SyncRequest.Type.jsont) ~enc:(fun r -> r.types)
2903 |> Jsont.Object.skip_unknown
2904 |> Jsont.Object.finish
2905 end
2906end
2907
2908module SyncPersonV1 = struct
2909 module Types = struct
2910 module T = struct
2911 type t = {
2912 birth_date : Ptime.t option;
2913 color : string option;
2914 created_at : Ptime.t;
2915 face_asset_id : string option;
2916 id : string;
2917 is_favorite : bool;
2918 is_hidden : bool;
2919 name : string;
2920 owner_id : string;
2921 updated_at : Ptime.t;
2922 }
2923 end
2924 end
2925
2926 module T = struct
2927 include Types.T
2928
2929 let v ~created_at ~id ~is_favorite ~is_hidden ~name ~owner_id ~updated_at ?birth_date ?color ?face_asset_id () = { birth_date; color; created_at; face_asset_id; id; is_favorite; is_hidden; name; owner_id; updated_at }
2930
2931 let birth_date t = t.birth_date
2932 let color t = t.color
2933 let created_at t = t.created_at
2934 let face_asset_id t = t.face_asset_id
2935 let id t = t.id
2936 let is_favorite t = t.is_favorite
2937 let is_hidden t = t.is_hidden
2938 let name t = t.name
2939 let owner_id t = t.owner_id
2940 let updated_at t = t.updated_at
2941
2942 let jsont : t Jsont.t =
2943 Jsont.Object.map ~kind:"SyncPersonV1"
2944 (fun birth_date color created_at face_asset_id id is_favorite is_hidden name owner_id updated_at -> { birth_date; color; created_at; face_asset_id; id; is_favorite; is_hidden; name; owner_id; updated_at })
2945 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_ptime
2946 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
2947 |> Jsont.Object.mem "color" Openapi.Runtime.nullable_string
2948 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.color)
2949 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
2950 |> Jsont.Object.mem "faceAssetId" Openapi.Runtime.nullable_string
2951 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.face_asset_id)
2952 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
2953 |> Jsont.Object.mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
2954 |> Jsont.Object.mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
2955 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
2956 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
2957 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
2958 |> Jsont.Object.skip_unknown
2959 |> Jsont.Object.finish
2960 end
2961end
2962
2963module SyncPersonDeleteV1 = struct
2964 module Types = struct
2965 module T = struct
2966 type t = {
2967 person_id : string;
2968 }
2969 end
2970 end
2971
2972 module T = struct
2973 include Types.T
2974
2975 let v ~person_id () = { person_id }
2976
2977 let person_id t = t.person_id
2978
2979 let jsont : t Jsont.t =
2980 Jsont.Object.map ~kind:"SyncPersonDeleteV1"
2981 (fun person_id -> { person_id })
2982 |> Jsont.Object.mem "personId" Jsont.string ~enc:(fun r -> r.person_id)
2983 |> Jsont.Object.skip_unknown
2984 |> Jsont.Object.finish
2985 end
2986end
2987
2988module SyncPartnerV1 = struct
2989 module Types = struct
2990 module T = struct
2991 type t = {
2992 in_timeline : bool;
2993 shared_by_id : string;
2994 shared_with_id : string;
2995 }
2996 end
2997 end
2998
2999 module T = struct
3000 include Types.T
3001
3002 let v ~in_timeline ~shared_by_id ~shared_with_id () = { in_timeline; shared_by_id; shared_with_id }
3003
3004 let in_timeline t = t.in_timeline
3005 let shared_by_id t = t.shared_by_id
3006 let shared_with_id t = t.shared_with_id
3007
3008 let jsont : t Jsont.t =
3009 Jsont.Object.map ~kind:"SyncPartnerV1"
3010 (fun in_timeline shared_by_id shared_with_id -> { in_timeline; shared_by_id; shared_with_id })
3011 |> Jsont.Object.mem "inTimeline" Jsont.bool ~enc:(fun r -> r.in_timeline)
3012 |> Jsont.Object.mem "sharedById" Jsont.string ~enc:(fun r -> r.shared_by_id)
3013 |> Jsont.Object.mem "sharedWithId" Jsont.string ~enc:(fun r -> r.shared_with_id)
3014 |> Jsont.Object.skip_unknown
3015 |> Jsont.Object.finish
3016 end
3017end
3018
3019module SyncPartnerDeleteV1 = struct
3020 module Types = struct
3021 module T = struct
3022 type t = {
3023 shared_by_id : string;
3024 shared_with_id : string;
3025 }
3026 end
3027 end
3028
3029 module T = struct
3030 include Types.T
3031
3032 let v ~shared_by_id ~shared_with_id () = { shared_by_id; shared_with_id }
3033
3034 let shared_by_id t = t.shared_by_id
3035 let shared_with_id t = t.shared_with_id
3036
3037 let jsont : t Jsont.t =
3038 Jsont.Object.map ~kind:"SyncPartnerDeleteV1"
3039 (fun shared_by_id shared_with_id -> { shared_by_id; shared_with_id })
3040 |> Jsont.Object.mem "sharedById" Jsont.string ~enc:(fun r -> r.shared_by_id)
3041 |> Jsont.Object.mem "sharedWithId" Jsont.string ~enc:(fun r -> r.shared_with_id)
3042 |> Jsont.Object.skip_unknown
3043 |> Jsont.Object.finish
3044 end
3045end
3046
3047module SyncMemoryDeleteV1 = struct
3048 module Types = struct
3049 module T = struct
3050 type t = {
3051 memory_id : string;
3052 }
3053 end
3054 end
3055
3056 module T = struct
3057 include Types.T
3058
3059 let v ~memory_id () = { memory_id }
3060
3061 let memory_id t = t.memory_id
3062
3063 let jsont : t Jsont.t =
3064 Jsont.Object.map ~kind:"SyncMemoryDeleteV1"
3065 (fun memory_id -> { memory_id })
3066 |> Jsont.Object.mem "memoryId" Jsont.string ~enc:(fun r -> r.memory_id)
3067 |> Jsont.Object.skip_unknown
3068 |> Jsont.Object.finish
3069 end
3070end
3071
3072module SyncMemoryAssetV1 = struct
3073 module Types = struct
3074 module T = struct
3075 type t = {
3076 asset_id : string;
3077 memory_id : string;
3078 }
3079 end
3080 end
3081
3082 module T = struct
3083 include Types.T
3084
3085 let v ~asset_id ~memory_id () = { asset_id; memory_id }
3086
3087 let asset_id t = t.asset_id
3088 let memory_id t = t.memory_id
3089
3090 let jsont : t Jsont.t =
3091 Jsont.Object.map ~kind:"SyncMemoryAssetV1"
3092 (fun asset_id memory_id -> { asset_id; memory_id })
3093 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3094 |> Jsont.Object.mem "memoryId" Jsont.string ~enc:(fun r -> r.memory_id)
3095 |> Jsont.Object.skip_unknown
3096 |> Jsont.Object.finish
3097 end
3098end
3099
3100module SyncMemoryAssetDeleteV1 = struct
3101 module Types = struct
3102 module T = struct
3103 type t = {
3104 asset_id : string;
3105 memory_id : string;
3106 }
3107 end
3108 end
3109
3110 module T = struct
3111 include Types.T
3112
3113 let v ~asset_id ~memory_id () = { asset_id; memory_id }
3114
3115 let asset_id t = t.asset_id
3116 let memory_id t = t.memory_id
3117
3118 let jsont : t Jsont.t =
3119 Jsont.Object.map ~kind:"SyncMemoryAssetDeleteV1"
3120 (fun asset_id memory_id -> { asset_id; memory_id })
3121 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3122 |> Jsont.Object.mem "memoryId" Jsont.string ~enc:(fun r -> r.memory_id)
3123 |> Jsont.Object.skip_unknown
3124 |> Jsont.Object.finish
3125 end
3126end
3127
3128module SyncEntity = struct
3129 module Types = struct
3130 module Type = struct
3131 type t = [
3132 | `Auth_user_v1
3133 | `User_v1
3134 | `User_delete_v1
3135 | `Asset_v1
3136 | `Asset_delete_v1
3137 | `Asset_exif_v1
3138 | `Asset_metadata_v1
3139 | `Asset_metadata_delete_v1
3140 | `Partner_v1
3141 | `Partner_delete_v1
3142 | `Partner_asset_v1
3143 | `Partner_asset_backfill_v1
3144 | `Partner_asset_delete_v1
3145 | `Partner_asset_exif_v1
3146 | `Partner_asset_exif_backfill_v1
3147 | `Partner_stack_backfill_v1
3148 | `Partner_stack_delete_v1
3149 | `Partner_stack_v1
3150 | `Album_v1
3151 | `Album_delete_v1
3152 | `Album_user_v1
3153 | `Album_user_backfill_v1
3154 | `Album_user_delete_v1
3155 | `Album_asset_create_v1
3156 | `Album_asset_update_v1
3157 | `Album_asset_backfill_v1
3158 | `Album_asset_exif_create_v1
3159 | `Album_asset_exif_update_v1
3160 | `Album_asset_exif_backfill_v1
3161 | `Album_to_asset_v1
3162 | `Album_to_asset_delete_v1
3163 | `Album_to_asset_backfill_v1
3164 | `Memory_v1
3165 | `Memory_delete_v1
3166 | `Memory_to_asset_v1
3167 | `Memory_to_asset_delete_v1
3168 | `Stack_v1
3169 | `Stack_delete_v1
3170 | `Person_v1
3171 | `Person_delete_v1
3172 | `Asset_face_v1
3173 | `Asset_face_delete_v1
3174 | `User_metadata_v1
3175 | `User_metadata_delete_v1
3176 | `Sync_ack_v1
3177 | `Sync_reset_v1
3178 | `Sync_complete_v1
3179 ]
3180 end
3181 end
3182
3183 module Type = struct
3184 include Types.Type
3185
3186 let jsont : t Jsont.t =
3187 Jsont.map Jsont.string ~kind:"SyncEntityType"
3188 ~dec:(function
3189 | "AuthUserV1" -> `Auth_user_v1
3190 | "UserV1" -> `User_v1
3191 | "UserDeleteV1" -> `User_delete_v1
3192 | "AssetV1" -> `Asset_v1
3193 | "AssetDeleteV1" -> `Asset_delete_v1
3194 | "AssetExifV1" -> `Asset_exif_v1
3195 | "AssetMetadataV1" -> `Asset_metadata_v1
3196 | "AssetMetadataDeleteV1" -> `Asset_metadata_delete_v1
3197 | "PartnerV1" -> `Partner_v1
3198 | "PartnerDeleteV1" -> `Partner_delete_v1
3199 | "PartnerAssetV1" -> `Partner_asset_v1
3200 | "PartnerAssetBackfillV1" -> `Partner_asset_backfill_v1
3201 | "PartnerAssetDeleteV1" -> `Partner_asset_delete_v1
3202 | "PartnerAssetExifV1" -> `Partner_asset_exif_v1
3203 | "PartnerAssetExifBackfillV1" -> `Partner_asset_exif_backfill_v1
3204 | "PartnerStackBackfillV1" -> `Partner_stack_backfill_v1
3205 | "PartnerStackDeleteV1" -> `Partner_stack_delete_v1
3206 | "PartnerStackV1" -> `Partner_stack_v1
3207 | "AlbumV1" -> `Album_v1
3208 | "AlbumDeleteV1" -> `Album_delete_v1
3209 | "AlbumUserV1" -> `Album_user_v1
3210 | "AlbumUserBackfillV1" -> `Album_user_backfill_v1
3211 | "AlbumUserDeleteV1" -> `Album_user_delete_v1
3212 | "AlbumAssetCreateV1" -> `Album_asset_create_v1
3213 | "AlbumAssetUpdateV1" -> `Album_asset_update_v1
3214 | "AlbumAssetBackfillV1" -> `Album_asset_backfill_v1
3215 | "AlbumAssetExifCreateV1" -> `Album_asset_exif_create_v1
3216 | "AlbumAssetExifUpdateV1" -> `Album_asset_exif_update_v1
3217 | "AlbumAssetExifBackfillV1" -> `Album_asset_exif_backfill_v1
3218 | "AlbumToAssetV1" -> `Album_to_asset_v1
3219 | "AlbumToAssetDeleteV1" -> `Album_to_asset_delete_v1
3220 | "AlbumToAssetBackfillV1" -> `Album_to_asset_backfill_v1
3221 | "MemoryV1" -> `Memory_v1
3222 | "MemoryDeleteV1" -> `Memory_delete_v1
3223 | "MemoryToAssetV1" -> `Memory_to_asset_v1
3224 | "MemoryToAssetDeleteV1" -> `Memory_to_asset_delete_v1
3225 | "StackV1" -> `Stack_v1
3226 | "StackDeleteV1" -> `Stack_delete_v1
3227 | "PersonV1" -> `Person_v1
3228 | "PersonDeleteV1" -> `Person_delete_v1
3229 | "AssetFaceV1" -> `Asset_face_v1
3230 | "AssetFaceDeleteV1" -> `Asset_face_delete_v1
3231 | "UserMetadataV1" -> `User_metadata_v1
3232 | "UserMetadataDeleteV1" -> `User_metadata_delete_v1
3233 | "SyncAckV1" -> `Sync_ack_v1
3234 | "SyncResetV1" -> `Sync_reset_v1
3235 | "SyncCompleteV1" -> `Sync_complete_v1
3236 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
3237 ~enc:(function
3238 | `Auth_user_v1 -> "AuthUserV1"
3239 | `User_v1 -> "UserV1"
3240 | `User_delete_v1 -> "UserDeleteV1"
3241 | `Asset_v1 -> "AssetV1"
3242 | `Asset_delete_v1 -> "AssetDeleteV1"
3243 | `Asset_exif_v1 -> "AssetExifV1"
3244 | `Asset_metadata_v1 -> "AssetMetadataV1"
3245 | `Asset_metadata_delete_v1 -> "AssetMetadataDeleteV1"
3246 | `Partner_v1 -> "PartnerV1"
3247 | `Partner_delete_v1 -> "PartnerDeleteV1"
3248 | `Partner_asset_v1 -> "PartnerAssetV1"
3249 | `Partner_asset_backfill_v1 -> "PartnerAssetBackfillV1"
3250 | `Partner_asset_delete_v1 -> "PartnerAssetDeleteV1"
3251 | `Partner_asset_exif_v1 -> "PartnerAssetExifV1"
3252 | `Partner_asset_exif_backfill_v1 -> "PartnerAssetExifBackfillV1"
3253 | `Partner_stack_backfill_v1 -> "PartnerStackBackfillV1"
3254 | `Partner_stack_delete_v1 -> "PartnerStackDeleteV1"
3255 | `Partner_stack_v1 -> "PartnerStackV1"
3256 | `Album_v1 -> "AlbumV1"
3257 | `Album_delete_v1 -> "AlbumDeleteV1"
3258 | `Album_user_v1 -> "AlbumUserV1"
3259 | `Album_user_backfill_v1 -> "AlbumUserBackfillV1"
3260 | `Album_user_delete_v1 -> "AlbumUserDeleteV1"
3261 | `Album_asset_create_v1 -> "AlbumAssetCreateV1"
3262 | `Album_asset_update_v1 -> "AlbumAssetUpdateV1"
3263 | `Album_asset_backfill_v1 -> "AlbumAssetBackfillV1"
3264 | `Album_asset_exif_create_v1 -> "AlbumAssetExifCreateV1"
3265 | `Album_asset_exif_update_v1 -> "AlbumAssetExifUpdateV1"
3266 | `Album_asset_exif_backfill_v1 -> "AlbumAssetExifBackfillV1"
3267 | `Album_to_asset_v1 -> "AlbumToAssetV1"
3268 | `Album_to_asset_delete_v1 -> "AlbumToAssetDeleteV1"
3269 | `Album_to_asset_backfill_v1 -> "AlbumToAssetBackfillV1"
3270 | `Memory_v1 -> "MemoryV1"
3271 | `Memory_delete_v1 -> "MemoryDeleteV1"
3272 | `Memory_to_asset_v1 -> "MemoryToAssetV1"
3273 | `Memory_to_asset_delete_v1 -> "MemoryToAssetDeleteV1"
3274 | `Stack_v1 -> "StackV1"
3275 | `Stack_delete_v1 -> "StackDeleteV1"
3276 | `Person_v1 -> "PersonV1"
3277 | `Person_delete_v1 -> "PersonDeleteV1"
3278 | `Asset_face_v1 -> "AssetFaceV1"
3279 | `Asset_face_delete_v1 -> "AssetFaceDeleteV1"
3280 | `User_metadata_v1 -> "UserMetadataV1"
3281 | `User_metadata_delete_v1 -> "UserMetadataDeleteV1"
3282 | `Sync_ack_v1 -> "SyncAckV1"
3283 | `Sync_reset_v1 -> "SyncResetV1"
3284 | `Sync_complete_v1 -> "SyncCompleteV1")
3285 end
3286end
3287
3288module SyncAckDelete = struct
3289 module Types = struct
3290 module Dto = struct
3291 type t = {
3292 types : SyncEntity.Type.t list option;
3293 }
3294 end
3295 end
3296
3297 module Dto = struct
3298 include Types.Dto
3299
3300 let v ?types () = { types }
3301
3302 let types t = t.types
3303
3304 let jsont : t Jsont.t =
3305 Jsont.Object.map ~kind:"SyncAckDeleteDto"
3306 (fun types -> { types })
3307 |> Jsont.Object.opt_mem "types" (Jsont.list SyncEntity.Type.jsont) ~enc:(fun r -> r.types)
3308 |> Jsont.Object.skip_unknown
3309 |> Jsont.Object.finish
3310 end
3311end
3312
3313module SyncAck = struct
3314 module Types = struct
3315 module Dto = struct
3316 type t = {
3317 ack : string;
3318 type_ : SyncEntity.Type.t;
3319 }
3320 end
3321 end
3322
3323 module Dto = struct
3324 include Types.Dto
3325
3326 let v ~ack ~type_ () = { ack; type_ }
3327
3328 let ack t = t.ack
3329 let type_ t = t.type_
3330
3331 let jsont : t Jsont.t =
3332 Jsont.Object.map ~kind:"SyncAckDto"
3333 (fun ack type_ -> { ack; type_ })
3334 |> Jsont.Object.mem "ack" Jsont.string ~enc:(fun r -> r.ack)
3335 |> Jsont.Object.mem "type" SyncEntity.Type.jsont ~enc:(fun r -> r.type_)
3336 |> Jsont.Object.skip_unknown
3337 |> Jsont.Object.finish
3338 end
3339
3340 (** Retrieve acknowledgements
3341
3342 Retrieve the synchronization acknowledgments for the current session. *)
3343 let get_sync_ack client () =
3344 let op_name = "get_sync_ack" in
3345 let url_path = "/sync/ack" in
3346 let query = "" in
3347 let url = client.base_url ^ url_path ^ query in
3348 let response =
3349 try Requests.get client.session url
3350 with Eio.Io _ as ex ->
3351 let bt = Printexc.get_raw_backtrace () in
3352 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
3353 in
3354 if Requests.Response.ok response then
3355 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
3356 else
3357 let body = Requests.Response.text response in
3358 let parsed_body =
3359 match Jsont_bytesrw.decode_string Jsont.json body with
3360 | Ok json -> Some (Openapi.Runtime.Json json)
3361 | Error _ -> Some (Openapi.Runtime.Raw body)
3362 in
3363 raise (Openapi.Runtime.Api_error {
3364 operation = op_name;
3365 method_ = "GET";
3366 url;
3367 status = Requests.Response.status_code response;
3368 body;
3369 parsed_body;
3370 })
3371end
3372
3373module SyncCompleteV1 = struct
3374 module Types = struct
3375 module T = struct
3376 type t = Jsont.json
3377 end
3378 end
3379
3380 module T = struct
3381 include Types.T
3382 let jsont = Jsont.json
3383 let v () = Jsont.Null ((), Jsont.Meta.none)
3384 end
3385end
3386
3387module SyncAssetMetadataV1 = struct
3388 module Types = struct
3389 module T = struct
3390 type t = {
3391 asset_id : string;
3392 key : string;
3393 value : Jsont.json;
3394 }
3395 end
3396 end
3397
3398 module T = struct
3399 include Types.T
3400
3401 let v ~asset_id ~key ~value () = { asset_id; key; value }
3402
3403 let asset_id t = t.asset_id
3404 let key t = t.key
3405 let value t = t.value
3406
3407 let jsont : t Jsont.t =
3408 Jsont.Object.map ~kind:"SyncAssetMetadataV1"
3409 (fun asset_id key value -> { asset_id; key; value })
3410 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3411 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
3412 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
3413 |> Jsont.Object.skip_unknown
3414 |> Jsont.Object.finish
3415 end
3416end
3417
3418module SyncAssetMetadataDeleteV1 = struct
3419 module Types = struct
3420 module T = struct
3421 type t = {
3422 asset_id : string;
3423 key : string;
3424 }
3425 end
3426 end
3427
3428 module T = struct
3429 include Types.T
3430
3431 let v ~asset_id ~key () = { asset_id; key }
3432
3433 let asset_id t = t.asset_id
3434 let key t = t.key
3435
3436 let jsont : t Jsont.t =
3437 Jsont.Object.map ~kind:"SyncAssetMetadataDeleteV1"
3438 (fun asset_id key -> { asset_id; key })
3439 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3440 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
3441 |> Jsont.Object.skip_unknown
3442 |> Jsont.Object.finish
3443 end
3444end
3445
3446module SyncAssetFaceV1 = struct
3447 module Types = struct
3448 module T = struct
3449 type t = {
3450 asset_id : string;
3451 bounding_box_x1 : int;
3452 bounding_box_x2 : int;
3453 bounding_box_y1 : int;
3454 bounding_box_y2 : int;
3455 id : string;
3456 image_height : int;
3457 image_width : int;
3458 person_id : string option;
3459 source_type : string;
3460 }
3461 end
3462 end
3463
3464 module T = struct
3465 include Types.T
3466
3467 let v ~asset_id ~bounding_box_x1 ~bounding_box_x2 ~bounding_box_y1 ~bounding_box_y2 ~id ~image_height ~image_width ~source_type ?person_id () = { asset_id; bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; person_id; source_type }
3468
3469 let asset_id t = t.asset_id
3470 let bounding_box_x1 t = t.bounding_box_x1
3471 let bounding_box_x2 t = t.bounding_box_x2
3472 let bounding_box_y1 t = t.bounding_box_y1
3473 let bounding_box_y2 t = t.bounding_box_y2
3474 let id t = t.id
3475 let image_height t = t.image_height
3476 let image_width t = t.image_width
3477 let person_id t = t.person_id
3478 let source_type t = t.source_type
3479
3480 let jsont : t Jsont.t =
3481 Jsont.Object.map ~kind:"SyncAssetFaceV1"
3482 (fun asset_id bounding_box_x1 bounding_box_x2 bounding_box_y1 bounding_box_y2 id image_height image_width person_id source_type -> { asset_id; bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; person_id; source_type })
3483 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3484 |> Jsont.Object.mem "boundingBoxX1" Jsont.int ~enc:(fun r -> r.bounding_box_x1)
3485 |> Jsont.Object.mem "boundingBoxX2" Jsont.int ~enc:(fun r -> r.bounding_box_x2)
3486 |> Jsont.Object.mem "boundingBoxY1" Jsont.int ~enc:(fun r -> r.bounding_box_y1)
3487 |> Jsont.Object.mem "boundingBoxY2" Jsont.int ~enc:(fun r -> r.bounding_box_y2)
3488 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
3489 |> Jsont.Object.mem "imageHeight" Jsont.int ~enc:(fun r -> r.image_height)
3490 |> Jsont.Object.mem "imageWidth" Jsont.int ~enc:(fun r -> r.image_width)
3491 |> Jsont.Object.mem "personId" Openapi.Runtime.nullable_string
3492 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.person_id)
3493 |> Jsont.Object.mem "sourceType" Jsont.string ~enc:(fun r -> r.source_type)
3494 |> Jsont.Object.skip_unknown
3495 |> Jsont.Object.finish
3496 end
3497end
3498
3499module SyncAssetFaceDeleteV1 = struct
3500 module Types = struct
3501 module T = struct
3502 type t = {
3503 asset_face_id : string;
3504 }
3505 end
3506 end
3507
3508 module T = struct
3509 include Types.T
3510
3511 let v ~asset_face_id () = { asset_face_id }
3512
3513 let asset_face_id t = t.asset_face_id
3514
3515 let jsont : t Jsont.t =
3516 Jsont.Object.map ~kind:"SyncAssetFaceDeleteV1"
3517 (fun asset_face_id -> { asset_face_id })
3518 |> Jsont.Object.mem "assetFaceId" Jsont.string ~enc:(fun r -> r.asset_face_id)
3519 |> Jsont.Object.skip_unknown
3520 |> Jsont.Object.finish
3521 end
3522end
3523
3524module SyncAssetExifV1 = struct
3525 module Types = struct
3526 module T = struct
3527 type t = {
3528 asset_id : string;
3529 city : string option;
3530 country : string option;
3531 date_time_original : Ptime.t option;
3532 description : string option;
3533 exif_image_height : int option;
3534 exif_image_width : int option;
3535 exposure_time : string option;
3536 f_number : float option;
3537 file_size_in_byte : int option;
3538 focal_length : float option;
3539 fps : float option;
3540 iso : int option;
3541 latitude : float option;
3542 lens_model : string option;
3543 longitude : float option;
3544 make : string option;
3545 model : string option;
3546 modify_date : Ptime.t option;
3547 orientation : string option;
3548 profile_description : string option;
3549 projection_type : string option;
3550 rating : int option;
3551 state : string option;
3552 time_zone : string option;
3553 }
3554 end
3555 end
3556
3557 module T = struct
3558 include Types.T
3559
3560 let v ~asset_id ?city ?country ?date_time_original ?description ?exif_image_height ?exif_image_width ?exposure_time ?f_number ?file_size_in_byte ?focal_length ?fps ?iso ?latitude ?lens_model ?longitude ?make ?model ?modify_date ?orientation ?profile_description ?projection_type ?rating ?state ?time_zone () = { asset_id; city; country; date_time_original; description; exif_image_height; exif_image_width; exposure_time; f_number; file_size_in_byte; focal_length; fps; iso; latitude; lens_model; longitude; make; model; modify_date; orientation; profile_description; projection_type; rating; state; time_zone }
3561
3562 let asset_id t = t.asset_id
3563 let city t = t.city
3564 let country t = t.country
3565 let date_time_original t = t.date_time_original
3566 let description t = t.description
3567 let exif_image_height t = t.exif_image_height
3568 let exif_image_width t = t.exif_image_width
3569 let exposure_time t = t.exposure_time
3570 let f_number t = t.f_number
3571 let file_size_in_byte t = t.file_size_in_byte
3572 let focal_length t = t.focal_length
3573 let fps t = t.fps
3574 let iso t = t.iso
3575 let latitude t = t.latitude
3576 let lens_model t = t.lens_model
3577 let longitude t = t.longitude
3578 let make t = t.make
3579 let model t = t.model
3580 let modify_date t = t.modify_date
3581 let orientation t = t.orientation
3582 let profile_description t = t.profile_description
3583 let projection_type t = t.projection_type
3584 let rating t = t.rating
3585 let state t = t.state
3586 let time_zone t = t.time_zone
3587
3588 let jsont : t Jsont.t =
3589 Jsont.Object.map ~kind:"SyncAssetExifV1"
3590 (fun asset_id city country date_time_original description exif_image_height exif_image_width exposure_time f_number file_size_in_byte focal_length fps iso latitude lens_model longitude make model modify_date orientation profile_description projection_type rating state time_zone -> { asset_id; city; country; date_time_original; description; exif_image_height; exif_image_width; exposure_time; f_number; file_size_in_byte; focal_length; fps; iso; latitude; lens_model; longitude; make; model; modify_date; orientation; profile_description; projection_type; rating; state; time_zone })
3591 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3592 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
3593 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
3594 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
3595 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
3596 |> Jsont.Object.mem "dateTimeOriginal" Openapi.Runtime.nullable_ptime
3597 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.date_time_original)
3598 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
3599 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
3600 |> Jsont.Object.mem "exifImageHeight" Openapi.Runtime.nullable_int
3601 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exif_image_height)
3602 |> Jsont.Object.mem "exifImageWidth" Openapi.Runtime.nullable_int
3603 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exif_image_width)
3604 |> Jsont.Object.mem "exposureTime" Openapi.Runtime.nullable_string
3605 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exposure_time)
3606 |> Jsont.Object.mem "fNumber" Openapi.Runtime.nullable_float
3607 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.f_number)
3608 |> Jsont.Object.mem "fileSizeInByte" Openapi.Runtime.nullable_int
3609 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.file_size_in_byte)
3610 |> Jsont.Object.mem "focalLength" Openapi.Runtime.nullable_float
3611 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.focal_length)
3612 |> Jsont.Object.mem "fps" Openapi.Runtime.nullable_float
3613 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.fps)
3614 |> Jsont.Object.mem "iso" Openapi.Runtime.nullable_int
3615 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.iso)
3616 |> Jsont.Object.mem "latitude" Openapi.Runtime.nullable_float
3617 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.latitude)
3618 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
3619 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
3620 |> Jsont.Object.mem "longitude" Openapi.Runtime.nullable_float
3621 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.longitude)
3622 |> Jsont.Object.mem "make" Openapi.Runtime.nullable_string
3623 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.make)
3624 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
3625 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
3626 |> Jsont.Object.mem "modifyDate" Openapi.Runtime.nullable_ptime
3627 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.modify_date)
3628 |> Jsont.Object.mem "orientation" Openapi.Runtime.nullable_string
3629 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.orientation)
3630 |> Jsont.Object.mem "profileDescription" Openapi.Runtime.nullable_string
3631 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.profile_description)
3632 |> Jsont.Object.mem "projectionType" Openapi.Runtime.nullable_string
3633 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.projection_type)
3634 |> Jsont.Object.mem "rating" Openapi.Runtime.nullable_int
3635 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.rating)
3636 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
3637 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
3638 |> Jsont.Object.mem "timeZone" Openapi.Runtime.nullable_string
3639 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.time_zone)
3640 |> Jsont.Object.skip_unknown
3641 |> Jsont.Object.finish
3642 end
3643end
3644
3645module SyncAssetDeleteV1 = struct
3646 module Types = struct
3647 module T = struct
3648 type t = {
3649 asset_id : string;
3650 }
3651 end
3652 end
3653
3654 module T = struct
3655 include Types.T
3656
3657 let v ~asset_id () = { asset_id }
3658
3659 let asset_id t = t.asset_id
3660
3661 let jsont : t Jsont.t =
3662 Jsont.Object.map ~kind:"SyncAssetDeleteV1"
3663 (fun asset_id -> { asset_id })
3664 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3665 |> Jsont.Object.skip_unknown
3666 |> Jsont.Object.finish
3667 end
3668end
3669
3670module SyncAlbumUserDeleteV1 = struct
3671 module Types = struct
3672 module T = struct
3673 type t = {
3674 album_id : string;
3675 user_id : string;
3676 }
3677 end
3678 end
3679
3680 module T = struct
3681 include Types.T
3682
3683 let v ~album_id ~user_id () = { album_id; user_id }
3684
3685 let album_id t = t.album_id
3686 let user_id t = t.user_id
3687
3688 let jsont : t Jsont.t =
3689 Jsont.Object.map ~kind:"SyncAlbumUserDeleteV1"
3690 (fun album_id user_id -> { album_id; user_id })
3691 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
3692 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
3693 |> Jsont.Object.skip_unknown
3694 |> Jsont.Object.finish
3695 end
3696end
3697
3698module SyncAlbumToAssetV1 = struct
3699 module Types = struct
3700 module T = struct
3701 type t = {
3702 album_id : string;
3703 asset_id : string;
3704 }
3705 end
3706 end
3707
3708 module T = struct
3709 include Types.T
3710
3711 let v ~album_id ~asset_id () = { album_id; asset_id }
3712
3713 let album_id t = t.album_id
3714 let asset_id t = t.asset_id
3715
3716 let jsont : t Jsont.t =
3717 Jsont.Object.map ~kind:"SyncAlbumToAssetV1"
3718 (fun album_id asset_id -> { album_id; asset_id })
3719 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
3720 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3721 |> Jsont.Object.skip_unknown
3722 |> Jsont.Object.finish
3723 end
3724end
3725
3726module SyncAlbumToAssetDeleteV1 = struct
3727 module Types = struct
3728 module T = struct
3729 type t = {
3730 album_id : string;
3731 asset_id : string;
3732 }
3733 end
3734 end
3735
3736 module T = struct
3737 include Types.T
3738
3739 let v ~album_id ~asset_id () = { album_id; asset_id }
3740
3741 let album_id t = t.album_id
3742 let asset_id t = t.asset_id
3743
3744 let jsont : t Jsont.t =
3745 Jsont.Object.map ~kind:"SyncAlbumToAssetDeleteV1"
3746 (fun album_id asset_id -> { album_id; asset_id })
3747 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
3748 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
3749 |> Jsont.Object.skip_unknown
3750 |> Jsont.Object.finish
3751 end
3752end
3753
3754module SyncAlbumDeleteV1 = struct
3755 module Types = struct
3756 module T = struct
3757 type t = {
3758 album_id : string;
3759 }
3760 end
3761 end
3762
3763 module T = struct
3764 include Types.T
3765
3766 let v ~album_id () = { album_id }
3767
3768 let album_id t = t.album_id
3769
3770 let jsont : t Jsont.t =
3771 Jsont.Object.map ~kind:"SyncAlbumDeleteV1"
3772 (fun album_id -> { album_id })
3773 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
3774 |> Jsont.Object.skip_unknown
3775 |> Jsont.Object.finish
3776 end
3777end
3778
3779module SyncAckV1 = struct
3780 module Types = struct
3781 module T = struct
3782 type t = Jsont.json
3783 end
3784 end
3785
3786 module T = struct
3787 include Types.T
3788 let jsont = Jsont.json
3789 let v () = Jsont.Null ((), Jsont.Meta.none)
3790 end
3791end
3792
3793module SyncAckSet = struct
3794 module Types = struct
3795 module Dto = struct
3796 type t = {
3797 acks : string list;
3798 }
3799 end
3800 end
3801
3802 module Dto = struct
3803 include Types.Dto
3804
3805 let v ~acks () = { acks }
3806
3807 let acks t = t.acks
3808
3809 let jsont : t Jsont.t =
3810 Jsont.Object.map ~kind:"SyncAckSetDto"
3811 (fun acks -> { acks })
3812 |> Jsont.Object.mem "acks" (Openapi.Runtime.validated_list ~max_items:1000 Jsont.string) ~enc:(fun r -> r.acks)
3813 |> Jsont.Object.skip_unknown
3814 |> Jsont.Object.finish
3815 end
3816end
3817
3818module StorageFolder = struct
3819 module Types = struct
3820 module T = struct
3821 type t = [
3822 | `Encoded_video
3823 | `Library
3824 | `Upload
3825 | `Profile
3826 | `Thumbs
3827 | `Backups
3828 ]
3829 end
3830 end
3831
3832 module T = struct
3833 include Types.T
3834
3835 let jsont : t Jsont.t =
3836 Jsont.map Jsont.string ~kind:"StorageFolder"
3837 ~dec:(function
3838 | "encoded-video" -> `Encoded_video
3839 | "library" -> `Library
3840 | "upload" -> `Upload
3841 | "profile" -> `Profile
3842 | "thumbs" -> `Thumbs
3843 | "backups" -> `Backups
3844 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
3845 ~enc:(function
3846 | `Encoded_video -> "encoded-video"
3847 | `Library -> "library"
3848 | `Upload -> "upload"
3849 | `Profile -> "profile"
3850 | `Thumbs -> "thumbs"
3851 | `Backups -> "backups")
3852 end
3853end
3854
3855module MaintenanceDetectInstallStorageFolder = struct
3856 module Types = struct
3857 module Dto = struct
3858 type t = {
3859 files : float;
3860 folder : StorageFolder.T.t;
3861 readable : bool;
3862 writable : bool;
3863 }
3864 end
3865 end
3866
3867 module Dto = struct
3868 include Types.Dto
3869
3870 let v ~files ~folder ~readable ~writable () = { files; folder; readable; writable }
3871
3872 let files t = t.files
3873 let folder t = t.folder
3874 let readable t = t.readable
3875 let writable t = t.writable
3876
3877 let jsont : t Jsont.t =
3878 Jsont.Object.map ~kind:"MaintenanceDetectInstallStorageFolderDto"
3879 (fun files folder readable writable -> { files; folder; readable; writable })
3880 |> Jsont.Object.mem "files" Jsont.number ~enc:(fun r -> r.files)
3881 |> Jsont.Object.mem "folder" StorageFolder.T.jsont ~enc:(fun r -> r.folder)
3882 |> Jsont.Object.mem "readable" Jsont.bool ~enc:(fun r -> r.readable)
3883 |> Jsont.Object.mem "writable" Jsont.bool ~enc:(fun r -> r.writable)
3884 |> Jsont.Object.skip_unknown
3885 |> Jsont.Object.finish
3886 end
3887end
3888
3889module MaintenanceDetectInstall = struct
3890 module Types = struct
3891 module ResponseDto = struct
3892 type t = {
3893 storage : MaintenanceDetectInstallStorageFolder.Dto.t list;
3894 }
3895 end
3896 end
3897
3898 module ResponseDto = struct
3899 include Types.ResponseDto
3900
3901 let v ~storage () = { storage }
3902
3903 let storage t = t.storage
3904
3905 let jsont : t Jsont.t =
3906 Jsont.Object.map ~kind:"MaintenanceDetectInstallResponseDto"
3907 (fun storage -> { storage })
3908 |> Jsont.Object.mem "storage" (Jsont.list MaintenanceDetectInstallStorageFolder.Dto.jsont) ~enc:(fun r -> r.storage)
3909 |> Jsont.Object.skip_unknown
3910 |> Jsont.Object.finish
3911 end
3912
3913 (** Detect existing install
3914
3915 Collect integrity checks and other heuristics about local data. *)
3916 let detect_prior_install client () =
3917 let op_name = "detect_prior_install" in
3918 let url_path = "/admin/maintenance/detect-install" in
3919 let query = "" in
3920 let url = client.base_url ^ url_path ^ query in
3921 let response =
3922 try Requests.get client.session url
3923 with Eio.Io _ as ex ->
3924 let bt = Printexc.get_raw_backtrace () in
3925 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
3926 in
3927 if Requests.Response.ok response then
3928 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
3929 else
3930 let body = Requests.Response.text response in
3931 let parsed_body =
3932 match Jsont_bytesrw.decode_string Jsont.json body with
3933 | Ok json -> Some (Openapi.Runtime.Json json)
3934 | Error _ -> Some (Openapi.Runtime.Raw body)
3935 in
3936 raise (Openapi.Runtime.Api_error {
3937 operation = op_name;
3938 method_ = "GET";
3939 url;
3940 status = Requests.Response.status_code response;
3941 body;
3942 parsed_body;
3943 })
3944end
3945
3946module Source = struct
3947 module Types = struct
3948 module Type = struct
3949 type t = [
3950 | `Machine_learning
3951 | `Exif
3952 | `Manual
3953 ]
3954 end
3955 end
3956
3957 module Type = struct
3958 include Types.Type
3959
3960 let jsont : t Jsont.t =
3961 Jsont.map Jsont.string ~kind:"SourceType"
3962 ~dec:(function
3963 | "machine-learning" -> `Machine_learning
3964 | "exif" -> `Exif
3965 | "manual" -> `Manual
3966 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
3967 ~enc:(function
3968 | `Machine_learning -> "machine-learning"
3969 | `Exif -> "exif"
3970 | `Manual -> "manual")
3971 end
3972end
3973
3974module AssetFaceWithoutPerson = struct
3975 module Types = struct
3976 module ResponseDto = struct
3977 type t = {
3978 bounding_box_x1 : int;
3979 bounding_box_x2 : int;
3980 bounding_box_y1 : int;
3981 bounding_box_y2 : int;
3982 id : string;
3983 image_height : int;
3984 image_width : int;
3985 source_type : Source.Type.t option;
3986 }
3987 end
3988 end
3989
3990 module ResponseDto = struct
3991 include Types.ResponseDto
3992
3993 let v ~bounding_box_x1 ~bounding_box_x2 ~bounding_box_y1 ~bounding_box_y2 ~id ~image_height ~image_width ?source_type () = { bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; source_type }
3994
3995 let bounding_box_x1 t = t.bounding_box_x1
3996 let bounding_box_x2 t = t.bounding_box_x2
3997 let bounding_box_y1 t = t.bounding_box_y1
3998 let bounding_box_y2 t = t.bounding_box_y2
3999 let id t = t.id
4000 let image_height t = t.image_height
4001 let image_width t = t.image_width
4002 let source_type t = t.source_type
4003
4004 let jsont : t Jsont.t =
4005 Jsont.Object.map ~kind:"AssetFaceWithoutPersonResponseDto"
4006 (fun bounding_box_x1 bounding_box_x2 bounding_box_y1 bounding_box_y2 id image_height image_width source_type -> { bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; source_type })
4007 |> Jsont.Object.mem "boundingBoxX1" Jsont.int ~enc:(fun r -> r.bounding_box_x1)
4008 |> Jsont.Object.mem "boundingBoxX2" Jsont.int ~enc:(fun r -> r.bounding_box_x2)
4009 |> Jsont.Object.mem "boundingBoxY1" Jsont.int ~enc:(fun r -> r.bounding_box_y1)
4010 |> Jsont.Object.mem "boundingBoxY2" Jsont.int ~enc:(fun r -> r.bounding_box_y2)
4011 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
4012 |> Jsont.Object.mem "imageHeight" Jsont.int ~enc:(fun r -> r.image_height)
4013 |> Jsont.Object.mem "imageWidth" Jsont.int ~enc:(fun r -> r.image_width)
4014 |> Jsont.Object.opt_mem "sourceType" Source.Type.jsont ~enc:(fun r -> r.source_type)
4015 |> Jsont.Object.skip_unknown
4016 |> Jsont.Object.finish
4017 end
4018end
4019
4020module PersonWithFaces = struct
4021 module Types = struct
4022 module ResponseDto = struct
4023 type t = {
4024 birth_date : string option;
4025 color : string option;
4026 faces : AssetFaceWithoutPerson.ResponseDto.t list;
4027 id : string;
4028 is_favorite : bool option;
4029 is_hidden : bool;
4030 name : string;
4031 thumbnail_path : string;
4032 updated_at : Ptime.t option;
4033 }
4034 end
4035 end
4036
4037 module ResponseDto = struct
4038 include Types.ResponseDto
4039
4040 let v ~faces ~id ~is_hidden ~name ~thumbnail_path ?birth_date ?color ?is_favorite ?updated_at () = { birth_date; color; faces; id; is_favorite; is_hidden; name; thumbnail_path; updated_at }
4041
4042 let birth_date t = t.birth_date
4043 let color t = t.color
4044 let faces t = t.faces
4045 let id t = t.id
4046 let is_favorite t = t.is_favorite
4047 let is_hidden t = t.is_hidden
4048 let name t = t.name
4049 let thumbnail_path t = t.thumbnail_path
4050 let updated_at t = t.updated_at
4051
4052 let jsont : t Jsont.t =
4053 Jsont.Object.map ~kind:"PersonWithFacesResponseDto"
4054 (fun birth_date color faces id is_favorite is_hidden name thumbnail_path updated_at -> { birth_date; color; faces; id; is_favorite; is_hidden; name; thumbnail_path; updated_at })
4055 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_string
4056 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
4057 |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
4058 |> Jsont.Object.mem "faces" (Jsont.list AssetFaceWithoutPerson.ResponseDto.jsont) ~enc:(fun r -> r.faces)
4059 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
4060 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
4061 |> Jsont.Object.mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
4062 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
4063 |> Jsont.Object.mem "thumbnailPath" Jsont.string ~enc:(fun r -> r.thumbnail_path)
4064 |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
4065 |> Jsont.Object.skip_unknown
4066 |> Jsont.Object.finish
4067 end
4068end
4069
4070module SignUp = struct
4071 module Types = struct
4072 module Dto = struct
4073 type t = {
4074 email : string;
4075 name : string;
4076 password : string;
4077 }
4078 end
4079 end
4080
4081 module Dto = struct
4082 include Types.Dto
4083
4084 let v ~email ~name ~password () = { email; name; password }
4085
4086 let email t = t.email
4087 let name t = t.name
4088 let password t = t.password
4089
4090 let jsont : t Jsont.t =
4091 Jsont.Object.map ~kind:"SignUpDto"
4092 (fun email name password -> { email; name; password })
4093 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
4094 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
4095 |> Jsont.Object.mem "password" Jsont.string ~enc:(fun r -> r.password)
4096 |> Jsont.Object.skip_unknown
4097 |> Jsont.Object.finish
4098 end
4099end
4100
4101module SharedLinks = struct
4102 module Types = struct
4103 module Update = struct
4104 type t = {
4105 enabled : bool option;
4106 sidebar_web : bool option;
4107 }
4108 end
4109
4110 module Response = struct
4111 type t = {
4112 enabled : bool;
4113 sidebar_web : bool;
4114 }
4115 end
4116 end
4117
4118 module Update = struct
4119 include Types.Update
4120
4121 let v ?enabled ?sidebar_web () = { enabled; sidebar_web }
4122
4123 let enabled t = t.enabled
4124 let sidebar_web t = t.sidebar_web
4125
4126 let jsont : t Jsont.t =
4127 Jsont.Object.map ~kind:"SharedLinksUpdate"
4128 (fun enabled sidebar_web -> { enabled; sidebar_web })
4129 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
4130 |> Jsont.Object.opt_mem "sidebarWeb" Jsont.bool ~enc:(fun r -> r.sidebar_web)
4131 |> Jsont.Object.skip_unknown
4132 |> Jsont.Object.finish
4133 end
4134
4135 module Response = struct
4136 include Types.Response
4137
4138 let v ?(enabled=true) ?(sidebar_web=false) () = { enabled; sidebar_web }
4139
4140 let enabled t = t.enabled
4141 let sidebar_web t = t.sidebar_web
4142
4143 let jsont : t Jsont.t =
4144 Jsont.Object.map ~kind:"SharedLinksResponse"
4145 (fun enabled sidebar_web -> { enabled; sidebar_web })
4146 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.enabled)
4147 |> Jsont.Object.mem "sidebarWeb" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.sidebar_web)
4148 |> Jsont.Object.skip_unknown
4149 |> Jsont.Object.finish
4150 end
4151end
4152
4153module SharedLinkEdit = struct
4154 module Types = struct
4155 module Dto = struct
4156 type t = {
4157 allow_download : bool option;
4158 allow_upload : bool option;
4159 change_expiry_time : bool option; (** Few clients cannot send null to set the expiryTime to never.
4160 Setting this flag and not sending expiryAt is considered as null instead.
4161 Clients that can send null values can ignore this. *)
4162 description : string option;
4163 expires_at : Ptime.t option;
4164 password : string option;
4165 show_metadata : bool option;
4166 slug : string option;
4167 }
4168 end
4169 end
4170
4171 module Dto = struct
4172 include Types.Dto
4173
4174 let v ?allow_download ?allow_upload ?change_expiry_time ?description ?expires_at ?password ?show_metadata ?slug () = { allow_download; allow_upload; change_expiry_time; description; expires_at; password; show_metadata; slug }
4175
4176 let allow_download t = t.allow_download
4177 let allow_upload t = t.allow_upload
4178 let change_expiry_time t = t.change_expiry_time
4179 let description t = t.description
4180 let expires_at t = t.expires_at
4181 let password t = t.password
4182 let show_metadata t = t.show_metadata
4183 let slug t = t.slug
4184
4185 let jsont : t Jsont.t =
4186 Jsont.Object.map ~kind:"SharedLinkEditDto"
4187 (fun allow_download allow_upload change_expiry_time description expires_at password show_metadata slug -> { allow_download; allow_upload; change_expiry_time; description; expires_at; password; show_metadata; slug })
4188 |> Jsont.Object.opt_mem "allowDownload" Jsont.bool ~enc:(fun r -> r.allow_download)
4189 |> Jsont.Object.opt_mem "allowUpload" Jsont.bool ~enc:(fun r -> r.allow_upload)
4190 |> Jsont.Object.opt_mem "changeExpiryTime" Jsont.bool ~enc:(fun r -> r.change_expiry_time)
4191 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
4192 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
4193 |> Jsont.Object.mem "expiresAt" Openapi.Runtime.nullable_ptime
4194 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.expires_at)
4195 |> Jsont.Object.mem "password" Openapi.Runtime.nullable_string
4196 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.password)
4197 |> Jsont.Object.opt_mem "showMetadata" Jsont.bool ~enc:(fun r -> r.show_metadata)
4198 |> Jsont.Object.mem "slug" Openapi.Runtime.nullable_string
4199 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.slug)
4200 |> Jsont.Object.skip_unknown
4201 |> Jsont.Object.finish
4202 end
4203end
4204
4205module SessionUnlock = struct
4206 module Types = struct
4207 module Dto = struct
4208 type t = {
4209 password : string option;
4210 pin_code : string option;
4211 }
4212 end
4213 end
4214
4215 module Dto = struct
4216 include Types.Dto
4217
4218 let v ?password ?pin_code () = { password; pin_code }
4219
4220 let password t = t.password
4221 let pin_code t = t.pin_code
4222
4223 let jsont : t Jsont.t =
4224 Jsont.Object.map ~kind:"SessionUnlockDto"
4225 (fun password pin_code -> { password; pin_code })
4226 |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
4227 |> Jsont.Object.opt_mem "pinCode" Jsont.string ~enc:(fun r -> r.pin_code)
4228 |> Jsont.Object.skip_unknown
4229 |> Jsont.Object.finish
4230 end
4231end
4232
4233module Session = struct
4234 module Types = struct
4235 module UpdateDto = struct
4236 type t = {
4237 is_pending_sync_reset : bool option;
4238 }
4239 end
4240
4241 module ResponseDto = struct
4242 type t = {
4243 app_version : string option;
4244 created_at : string;
4245 current : bool;
4246 device_os : string;
4247 device_type : string;
4248 expires_at : string option;
4249 id : string;
4250 is_pending_sync_reset : bool;
4251 updated_at : string;
4252 }
4253 end
4254
4255 module CreateDto = struct
4256 type t = {
4257 device_os : string option;
4258 device_type : string option;
4259 duration : float option; (** session duration, in seconds *)
4260 }
4261 end
4262 end
4263
4264 module UpdateDto = struct
4265 include Types.UpdateDto
4266
4267 let v ?is_pending_sync_reset () = { is_pending_sync_reset }
4268
4269 let is_pending_sync_reset t = t.is_pending_sync_reset
4270
4271 let jsont : t Jsont.t =
4272 Jsont.Object.map ~kind:"SessionUpdateDto"
4273 (fun is_pending_sync_reset -> { is_pending_sync_reset })
4274 |> Jsont.Object.opt_mem "isPendingSyncReset" Jsont.bool ~enc:(fun r -> r.is_pending_sync_reset)
4275 |> Jsont.Object.skip_unknown
4276 |> Jsont.Object.finish
4277 end
4278
4279 module ResponseDto = struct
4280 include Types.ResponseDto
4281
4282 let v ~created_at ~current ~device_os ~device_type ~id ~is_pending_sync_reset ~updated_at ?app_version ?expires_at () = { app_version; created_at; current; device_os; device_type; expires_at; id; is_pending_sync_reset; updated_at }
4283
4284 let app_version t = t.app_version
4285 let created_at t = t.created_at
4286 let current t = t.current
4287 let device_os t = t.device_os
4288 let device_type t = t.device_type
4289 let expires_at t = t.expires_at
4290 let id t = t.id
4291 let is_pending_sync_reset t = t.is_pending_sync_reset
4292 let updated_at t = t.updated_at
4293
4294 let jsont : t Jsont.t =
4295 Jsont.Object.map ~kind:"SessionResponseDto"
4296 (fun app_version created_at current device_os device_type expires_at id is_pending_sync_reset updated_at -> { app_version; created_at; current; device_os; device_type; expires_at; id; is_pending_sync_reset; updated_at })
4297 |> Jsont.Object.mem "appVersion" Openapi.Runtime.nullable_string
4298 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.app_version)
4299 |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
4300 |> Jsont.Object.mem "current" Jsont.bool ~enc:(fun r -> r.current)
4301 |> Jsont.Object.mem "deviceOS" Jsont.string ~enc:(fun r -> r.device_os)
4302 |> Jsont.Object.mem "deviceType" Jsont.string ~enc:(fun r -> r.device_type)
4303 |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
4304 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
4305 |> Jsont.Object.mem "isPendingSyncReset" Jsont.bool ~enc:(fun r -> r.is_pending_sync_reset)
4306 |> Jsont.Object.mem "updatedAt" Jsont.string ~enc:(fun r -> r.updated_at)
4307 |> Jsont.Object.skip_unknown
4308 |> Jsont.Object.finish
4309 end
4310
4311 module CreateDto = struct
4312 include Types.CreateDto
4313
4314 let v ?device_os ?device_type ?duration () = { device_os; device_type; duration }
4315
4316 let device_os t = t.device_os
4317 let device_type t = t.device_type
4318 let duration t = t.duration
4319
4320 let jsont : t Jsont.t =
4321 Jsont.Object.map ~kind:"SessionCreateDto"
4322 (fun device_os device_type duration -> { device_os; device_type; duration })
4323 |> Jsont.Object.opt_mem "deviceOS" Jsont.string ~enc:(fun r -> r.device_os)
4324 |> Jsont.Object.opt_mem "deviceType" Jsont.string ~enc:(fun r -> r.device_type)
4325 |> Jsont.Object.opt_mem "duration" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.duration)
4326 |> Jsont.Object.skip_unknown
4327 |> Jsont.Object.finish
4328 end
4329
4330 (** Retrieve user sessions
4331
4332 Retrieve all sessions for a specific user. *)
4333 let get_user_sessions_admin ~id client () =
4334 let op_name = "get_user_sessions_admin" in
4335 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}/sessions" in
4336 let query = "" in
4337 let url = client.base_url ^ url_path ^ query in
4338 let response =
4339 try Requests.get client.session url
4340 with Eio.Io _ as ex ->
4341 let bt = Printexc.get_raw_backtrace () in
4342 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4343 in
4344 if Requests.Response.ok response then
4345 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4346 else
4347 let body = Requests.Response.text response in
4348 let parsed_body =
4349 match Jsont_bytesrw.decode_string Jsont.json body with
4350 | Ok json -> Some (Openapi.Runtime.Json json)
4351 | Error _ -> Some (Openapi.Runtime.Raw body)
4352 in
4353 raise (Openapi.Runtime.Api_error {
4354 operation = op_name;
4355 method_ = "GET";
4356 url;
4357 status = Requests.Response.status_code response;
4358 body;
4359 parsed_body;
4360 })
4361
4362 (** Retrieve sessions
4363
4364 Retrieve a list of sessions for the user. *)
4365 let get_sessions client () =
4366 let op_name = "get_sessions" in
4367 let url_path = "/sessions" in
4368 let query = "" in
4369 let url = client.base_url ^ url_path ^ query in
4370 let response =
4371 try Requests.get client.session url
4372 with Eio.Io _ as ex ->
4373 let bt = Printexc.get_raw_backtrace () in
4374 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4375 in
4376 if Requests.Response.ok response then
4377 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4378 else
4379 let body = Requests.Response.text response in
4380 let parsed_body =
4381 match Jsont_bytesrw.decode_string Jsont.json body with
4382 | Ok json -> Some (Openapi.Runtime.Json json)
4383 | Error _ -> Some (Openapi.Runtime.Raw body)
4384 in
4385 raise (Openapi.Runtime.Api_error {
4386 operation = op_name;
4387 method_ = "GET";
4388 url;
4389 status = Requests.Response.status_code response;
4390 body;
4391 parsed_body;
4392 })
4393
4394 (** Update a session
4395
4396 Update a specific session identified by id. *)
4397 let update_session ~id ~body client () =
4398 let op_name = "update_session" in
4399 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/sessions/{id}" in
4400 let query = "" in
4401 let url = client.base_url ^ url_path ^ query in
4402 let response =
4403 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
4404 with Eio.Io _ as ex ->
4405 let bt = Printexc.get_raw_backtrace () in
4406 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
4407 in
4408 if Requests.Response.ok response then
4409 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4410 else
4411 let body = Requests.Response.text response in
4412 let parsed_body =
4413 match Jsont_bytesrw.decode_string Jsont.json body with
4414 | Ok json -> Some (Openapi.Runtime.Json json)
4415 | Error _ -> Some (Openapi.Runtime.Raw body)
4416 in
4417 raise (Openapi.Runtime.Api_error {
4418 operation = op_name;
4419 method_ = "PUT";
4420 url;
4421 status = Requests.Response.status_code response;
4422 body;
4423 parsed_body;
4424 })
4425end
4426
4427module SessionCreate = struct
4428 module Types = struct
4429 module ResponseDto = struct
4430 type t = {
4431 app_version : string option;
4432 created_at : string;
4433 current : bool;
4434 device_os : string;
4435 device_type : string;
4436 expires_at : string option;
4437 id : string;
4438 is_pending_sync_reset : bool;
4439 token : string;
4440 updated_at : string;
4441 }
4442 end
4443 end
4444
4445 module ResponseDto = struct
4446 include Types.ResponseDto
4447
4448 let v ~created_at ~current ~device_os ~device_type ~id ~is_pending_sync_reset ~token ~updated_at ?app_version ?expires_at () = { app_version; created_at; current; device_os; device_type; expires_at; id; is_pending_sync_reset; token; updated_at }
4449
4450 let app_version t = t.app_version
4451 let created_at t = t.created_at
4452 let current t = t.current
4453 let device_os t = t.device_os
4454 let device_type t = t.device_type
4455 let expires_at t = t.expires_at
4456 let id t = t.id
4457 let is_pending_sync_reset t = t.is_pending_sync_reset
4458 let token t = t.token
4459 let updated_at t = t.updated_at
4460
4461 let jsont : t Jsont.t =
4462 Jsont.Object.map ~kind:"SessionCreateResponseDto"
4463 (fun app_version created_at current device_os device_type expires_at id is_pending_sync_reset token updated_at -> { app_version; created_at; current; device_os; device_type; expires_at; id; is_pending_sync_reset; token; updated_at })
4464 |> Jsont.Object.mem "appVersion" Openapi.Runtime.nullable_string
4465 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.app_version)
4466 |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
4467 |> Jsont.Object.mem "current" Jsont.bool ~enc:(fun r -> r.current)
4468 |> Jsont.Object.mem "deviceOS" Jsont.string ~enc:(fun r -> r.device_os)
4469 |> Jsont.Object.mem "deviceType" Jsont.string ~enc:(fun r -> r.device_type)
4470 |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
4471 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
4472 |> Jsont.Object.mem "isPendingSyncReset" Jsont.bool ~enc:(fun r -> r.is_pending_sync_reset)
4473 |> Jsont.Object.mem "token" Jsont.string ~enc:(fun r -> r.token)
4474 |> Jsont.Object.mem "updatedAt" Jsont.string ~enc:(fun r -> r.updated_at)
4475 |> Jsont.Object.skip_unknown
4476 |> Jsont.Object.finish
4477 end
4478
4479 (** Create a session
4480
4481 Create a session as a child to the current session. This endpoint is used for casting. *)
4482 let create_session ~body client () =
4483 let op_name = "create_session" in
4484 let url_path = "/sessions" in
4485 let query = "" in
4486 let url = client.base_url ^ url_path ^ query in
4487 let response =
4488 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Session.CreateDto.jsont body)) url
4489 with Eio.Io _ as ex ->
4490 let bt = Printexc.get_raw_backtrace () in
4491 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
4492 in
4493 if Requests.Response.ok response then
4494 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4495 else
4496 let body = Requests.Response.text response in
4497 let parsed_body =
4498 match Jsont_bytesrw.decode_string Jsont.json body with
4499 | Ok json -> Some (Openapi.Runtime.Json json)
4500 | Error _ -> Some (Openapi.Runtime.Raw body)
4501 in
4502 raise (Openapi.Runtime.Api_error {
4503 operation = op_name;
4504 method_ = "POST";
4505 url;
4506 status = Requests.Response.status_code response;
4507 body;
4508 parsed_body;
4509 })
4510end
4511
4512module ServerVersionHistory = struct
4513 module Types = struct
4514 module ResponseDto = struct
4515 type t = {
4516 created_at : Ptime.t;
4517 id : string;
4518 version : string;
4519 }
4520 end
4521 end
4522
4523 module ResponseDto = struct
4524 include Types.ResponseDto
4525
4526 let v ~created_at ~id ~version () = { created_at; id; version }
4527
4528 let created_at t = t.created_at
4529 let id t = t.id
4530 let version t = t.version
4531
4532 let jsont : t Jsont.t =
4533 Jsont.Object.map ~kind:"ServerVersionHistoryResponseDto"
4534 (fun created_at id version -> { created_at; id; version })
4535 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
4536 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
4537 |> Jsont.Object.mem "version" Jsont.string ~enc:(fun r -> r.version)
4538 |> Jsont.Object.skip_unknown
4539 |> Jsont.Object.finish
4540 end
4541
4542 (** Get version history
4543
4544 Retrieve a list of past versions the server has been on. *)
4545 let get_version_history client () =
4546 let op_name = "get_version_history" in
4547 let url_path = "/server/version-history" in
4548 let query = "" in
4549 let url = client.base_url ^ url_path ^ query in
4550 let response =
4551 try Requests.get client.session url
4552 with Eio.Io _ as ex ->
4553 let bt = Printexc.get_raw_backtrace () in
4554 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4555 in
4556 if Requests.Response.ok response then
4557 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4558 else
4559 let body = Requests.Response.text response in
4560 let parsed_body =
4561 match Jsont_bytesrw.decode_string Jsont.json body with
4562 | Ok json -> Some (Openapi.Runtime.Json json)
4563 | Error _ -> Some (Openapi.Runtime.Raw body)
4564 in
4565 raise (Openapi.Runtime.Api_error {
4566 operation = op_name;
4567 method_ = "GET";
4568 url;
4569 status = Requests.Response.status_code response;
4570 body;
4571 parsed_body;
4572 })
4573end
4574
4575module ServerVersion = struct
4576 module Types = struct
4577 module ResponseDto = struct
4578 type t = {
4579 major : int;
4580 minor : int;
4581 patch : int;
4582 }
4583 end
4584 end
4585
4586 module ResponseDto = struct
4587 include Types.ResponseDto
4588
4589 let v ~major ~minor ~patch () = { major; minor; patch }
4590
4591 let major t = t.major
4592 let minor t = t.minor
4593 let patch t = t.patch
4594
4595 let jsont : t Jsont.t =
4596 Jsont.Object.map ~kind:"ServerVersionResponseDto"
4597 (fun major minor patch -> { major; minor; patch })
4598 |> Jsont.Object.mem "major" Jsont.int ~enc:(fun r -> r.major)
4599 |> Jsont.Object.mem "minor" Jsont.int ~enc:(fun r -> r.minor)
4600 |> Jsont.Object.mem "patch" Jsont.int ~enc:(fun r -> r.patch)
4601 |> Jsont.Object.skip_unknown
4602 |> Jsont.Object.finish
4603 end
4604
4605 (** Get server version
4606
4607 Retrieve the current server version in semantic versioning (semver) format. *)
4608 let get_server_version client () =
4609 let op_name = "get_server_version" in
4610 let url_path = "/server/version" in
4611 let query = "" in
4612 let url = client.base_url ^ url_path ^ query in
4613 let response =
4614 try Requests.get client.session url
4615 with Eio.Io _ as ex ->
4616 let bt = Printexc.get_raw_backtrace () in
4617 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4618 in
4619 if Requests.Response.ok response then
4620 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4621 else
4622 let body = Requests.Response.text response in
4623 let parsed_body =
4624 match Jsont_bytesrw.decode_string Jsont.json body with
4625 | Ok json -> Some (Openapi.Runtime.Json json)
4626 | Error _ -> Some (Openapi.Runtime.Raw body)
4627 in
4628 raise (Openapi.Runtime.Api_error {
4629 operation = op_name;
4630 method_ = "GET";
4631 url;
4632 status = Requests.Response.status_code response;
4633 body;
4634 parsed_body;
4635 })
4636end
4637
4638module ServerTheme = struct
4639 module Types = struct
4640 module Dto = struct
4641 type t = {
4642 custom_css : string;
4643 }
4644 end
4645 end
4646
4647 module Dto = struct
4648 include Types.Dto
4649
4650 let v ~custom_css () = { custom_css }
4651
4652 let custom_css t = t.custom_css
4653
4654 let jsont : t Jsont.t =
4655 Jsont.Object.map ~kind:"ServerThemeDto"
4656 (fun custom_css -> { custom_css })
4657 |> Jsont.Object.mem "customCss" Jsont.string ~enc:(fun r -> r.custom_css)
4658 |> Jsont.Object.skip_unknown
4659 |> Jsont.Object.finish
4660 end
4661
4662 (** Get theme
4663
4664 Retrieve the custom CSS, if existent. *)
4665 let get_theme client () =
4666 let op_name = "get_theme" in
4667 let url_path = "/server/theme" in
4668 let query = "" in
4669 let url = client.base_url ^ url_path ^ query in
4670 let response =
4671 try Requests.get client.session url
4672 with Eio.Io _ as ex ->
4673 let bt = Printexc.get_raw_backtrace () in
4674 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4675 in
4676 if Requests.Response.ok response then
4677 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
4678 else
4679 let body = Requests.Response.text response in
4680 let parsed_body =
4681 match Jsont_bytesrw.decode_string Jsont.json body with
4682 | Ok json -> Some (Openapi.Runtime.Json json)
4683 | Error _ -> Some (Openapi.Runtime.Raw body)
4684 in
4685 raise (Openapi.Runtime.Api_error {
4686 operation = op_name;
4687 method_ = "GET";
4688 url;
4689 status = Requests.Response.status_code response;
4690 body;
4691 parsed_body;
4692 })
4693end
4694
4695module ServerStorage = struct
4696 module Types = struct
4697 module ResponseDto = struct
4698 type t = {
4699 disk_available : string;
4700 disk_available_raw : int64;
4701 disk_size : string;
4702 disk_size_raw : int64;
4703 disk_usage_percentage : float;
4704 disk_use : string;
4705 disk_use_raw : int64;
4706 }
4707 end
4708 end
4709
4710 module ResponseDto = struct
4711 include Types.ResponseDto
4712
4713 let v ~disk_available ~disk_available_raw ~disk_size ~disk_size_raw ~disk_usage_percentage ~disk_use ~disk_use_raw () = { disk_available; disk_available_raw; disk_size; disk_size_raw; disk_usage_percentage; disk_use; disk_use_raw }
4714
4715 let disk_available t = t.disk_available
4716 let disk_available_raw t = t.disk_available_raw
4717 let disk_size t = t.disk_size
4718 let disk_size_raw t = t.disk_size_raw
4719 let disk_usage_percentage t = t.disk_usage_percentage
4720 let disk_use t = t.disk_use
4721 let disk_use_raw t = t.disk_use_raw
4722
4723 let jsont : t Jsont.t =
4724 Jsont.Object.map ~kind:"ServerStorageResponseDto"
4725 (fun disk_available disk_available_raw disk_size disk_size_raw disk_usage_percentage disk_use disk_use_raw -> { disk_available; disk_available_raw; disk_size; disk_size_raw; disk_usage_percentage; disk_use; disk_use_raw })
4726 |> Jsont.Object.mem "diskAvailable" Jsont.string ~enc:(fun r -> r.disk_available)
4727 |> Jsont.Object.mem "diskAvailableRaw" Jsont.int64 ~enc:(fun r -> r.disk_available_raw)
4728 |> Jsont.Object.mem "diskSize" Jsont.string ~enc:(fun r -> r.disk_size)
4729 |> Jsont.Object.mem "diskSizeRaw" Jsont.int64 ~enc:(fun r -> r.disk_size_raw)
4730 |> Jsont.Object.mem "diskUsagePercentage" Jsont.number ~enc:(fun r -> r.disk_usage_percentage)
4731 |> Jsont.Object.mem "diskUse" Jsont.string ~enc:(fun r -> r.disk_use)
4732 |> Jsont.Object.mem "diskUseRaw" Jsont.int64 ~enc:(fun r -> r.disk_use_raw)
4733 |> Jsont.Object.skip_unknown
4734 |> Jsont.Object.finish
4735 end
4736
4737 (** Get storage
4738
4739 Retrieve the current storage utilization information of the server. *)
4740 let get_storage client () =
4741 let op_name = "get_storage" in
4742 let url_path = "/server/storage" in
4743 let query = "" in
4744 let url = client.base_url ^ url_path ^ query in
4745 let response =
4746 try Requests.get client.session url
4747 with Eio.Io _ as ex ->
4748 let bt = Printexc.get_raw_backtrace () in
4749 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4750 in
4751 if Requests.Response.ok response then
4752 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4753 else
4754 let body = Requests.Response.text response in
4755 let parsed_body =
4756 match Jsont_bytesrw.decode_string Jsont.json body with
4757 | Ok json -> Some (Openapi.Runtime.Json json)
4758 | Error _ -> Some (Openapi.Runtime.Raw body)
4759 in
4760 raise (Openapi.Runtime.Api_error {
4761 operation = op_name;
4762 method_ = "GET";
4763 url;
4764 status = Requests.Response.status_code response;
4765 body;
4766 parsed_body;
4767 })
4768end
4769
4770module ServerPing = struct
4771 module Types = struct
4772 module Response = struct
4773 type t = {
4774 res : string;
4775 }
4776 end
4777 end
4778
4779 module Response = struct
4780 include Types.Response
4781
4782 let v ~res () = { res }
4783
4784 let res t = t.res
4785
4786 let jsont : t Jsont.t =
4787 Jsont.Object.map ~kind:"ServerPingResponse"
4788 (fun res -> { res })
4789 |> Jsont.Object.mem "res" Jsont.string ~enc:(fun r -> r.res)
4790 |> Jsont.Object.skip_unknown
4791 |> Jsont.Object.finish
4792 end
4793
4794 (** Ping
4795
4796 Pong *)
4797 let ping_server client () =
4798 let op_name = "ping_server" in
4799 let url_path = "/server/ping" in
4800 let query = "" in
4801 let url = client.base_url ^ url_path ^ query in
4802 let response =
4803 try Requests.get client.session url
4804 with Eio.Io _ as ex ->
4805 let bt = Printexc.get_raw_backtrace () in
4806 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4807 in
4808 if Requests.Response.ok response then
4809 Openapi.Runtime.Json.decode_json_exn Response.jsont (Requests.Response.json response)
4810 else
4811 let body = Requests.Response.text response in
4812 let parsed_body =
4813 match Jsont_bytesrw.decode_string Jsont.json body with
4814 | Ok json -> Some (Openapi.Runtime.Json json)
4815 | Error _ -> Some (Openapi.Runtime.Raw body)
4816 in
4817 raise (Openapi.Runtime.Api_error {
4818 operation = op_name;
4819 method_ = "GET";
4820 url;
4821 status = Requests.Response.status_code response;
4822 body;
4823 parsed_body;
4824 })
4825end
4826
4827module ServerMediaTypes = struct
4828 module Types = struct
4829 module ResponseDto = struct
4830 type t = {
4831 image : string list;
4832 sidecar : string list;
4833 video : string list;
4834 }
4835 end
4836 end
4837
4838 module ResponseDto = struct
4839 include Types.ResponseDto
4840
4841 let v ~image ~sidecar ~video () = { image; sidecar; video }
4842
4843 let image t = t.image
4844 let sidecar t = t.sidecar
4845 let video t = t.video
4846
4847 let jsont : t Jsont.t =
4848 Jsont.Object.map ~kind:"ServerMediaTypesResponseDto"
4849 (fun image sidecar video -> { image; sidecar; video })
4850 |> Jsont.Object.mem "image" (Jsont.list Jsont.string) ~enc:(fun r -> r.image)
4851 |> Jsont.Object.mem "sidecar" (Jsont.list Jsont.string) ~enc:(fun r -> r.sidecar)
4852 |> Jsont.Object.mem "video" (Jsont.list Jsont.string) ~enc:(fun r -> r.video)
4853 |> Jsont.Object.skip_unknown
4854 |> Jsont.Object.finish
4855 end
4856
4857 (** Get supported media types
4858
4859 Retrieve all media types supported by the server. *)
4860 let get_supported_media_types client () =
4861 let op_name = "get_supported_media_types" in
4862 let url_path = "/server/media-types" in
4863 let query = "" in
4864 let url = client.base_url ^ url_path ^ query in
4865 let response =
4866 try Requests.get client.session url
4867 with Eio.Io _ as ex ->
4868 let bt = Printexc.get_raw_backtrace () in
4869 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4870 in
4871 if Requests.Response.ok response then
4872 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
4873 else
4874 let body = Requests.Response.text response in
4875 let parsed_body =
4876 match Jsont_bytesrw.decode_string Jsont.json body with
4877 | Ok json -> Some (Openapi.Runtime.Json json)
4878 | Error _ -> Some (Openapi.Runtime.Raw body)
4879 in
4880 raise (Openapi.Runtime.Api_error {
4881 operation = op_name;
4882 method_ = "GET";
4883 url;
4884 status = Requests.Response.status_code response;
4885 body;
4886 parsed_body;
4887 })
4888end
4889
4890module ServerFeatures = struct
4891 module Types = struct
4892 module Dto = struct
4893 type t = {
4894 config_file : bool;
4895 duplicate_detection : bool;
4896 email : bool;
4897 facial_recognition : bool;
4898 import_faces : bool;
4899 map : bool;
4900 oauth : bool;
4901 oauth_auto_launch : bool;
4902 ocr : bool;
4903 password_login : bool;
4904 reverse_geocoding : bool;
4905 search : bool;
4906 sidecar : bool;
4907 smart_search : bool;
4908 trash : bool;
4909 }
4910 end
4911 end
4912
4913 module Dto = struct
4914 include Types.Dto
4915
4916 let v ~config_file ~duplicate_detection ~email ~facial_recognition ~import_faces ~map ~oauth ~oauth_auto_launch ~ocr ~password_login ~reverse_geocoding ~search ~sidecar ~smart_search ~trash () = { config_file; duplicate_detection; email; facial_recognition; import_faces; map; oauth; oauth_auto_launch; ocr; password_login; reverse_geocoding; search; sidecar; smart_search; trash }
4917
4918 let config_file t = t.config_file
4919 let duplicate_detection t = t.duplicate_detection
4920 let email t = t.email
4921 let facial_recognition t = t.facial_recognition
4922 let import_faces t = t.import_faces
4923 let map t = t.map
4924 let oauth t = t.oauth
4925 let oauth_auto_launch t = t.oauth_auto_launch
4926 let ocr t = t.ocr
4927 let password_login t = t.password_login
4928 let reverse_geocoding t = t.reverse_geocoding
4929 let search t = t.search
4930 let sidecar t = t.sidecar
4931 let smart_search t = t.smart_search
4932 let trash t = t.trash
4933
4934 let jsont : t Jsont.t =
4935 Jsont.Object.map ~kind:"ServerFeaturesDto"
4936 (fun config_file duplicate_detection email facial_recognition import_faces map oauth oauth_auto_launch ocr password_login reverse_geocoding search sidecar smart_search trash -> { config_file; duplicate_detection; email; facial_recognition; import_faces; map; oauth; oauth_auto_launch; ocr; password_login; reverse_geocoding; search; sidecar; smart_search; trash })
4937 |> Jsont.Object.mem "configFile" Jsont.bool ~enc:(fun r -> r.config_file)
4938 |> Jsont.Object.mem "duplicateDetection" Jsont.bool ~enc:(fun r -> r.duplicate_detection)
4939 |> Jsont.Object.mem "email" Jsont.bool ~enc:(fun r -> r.email)
4940 |> Jsont.Object.mem "facialRecognition" Jsont.bool ~enc:(fun r -> r.facial_recognition)
4941 |> Jsont.Object.mem "importFaces" Jsont.bool ~enc:(fun r -> r.import_faces)
4942 |> Jsont.Object.mem "map" Jsont.bool ~enc:(fun r -> r.map)
4943 |> Jsont.Object.mem "oauth" Jsont.bool ~enc:(fun r -> r.oauth)
4944 |> Jsont.Object.mem "oauthAutoLaunch" Jsont.bool ~enc:(fun r -> r.oauth_auto_launch)
4945 |> Jsont.Object.mem "ocr" Jsont.bool ~enc:(fun r -> r.ocr)
4946 |> Jsont.Object.mem "passwordLogin" Jsont.bool ~enc:(fun r -> r.password_login)
4947 |> Jsont.Object.mem "reverseGeocoding" Jsont.bool ~enc:(fun r -> r.reverse_geocoding)
4948 |> Jsont.Object.mem "search" Jsont.bool ~enc:(fun r -> r.search)
4949 |> Jsont.Object.mem "sidecar" Jsont.bool ~enc:(fun r -> r.sidecar)
4950 |> Jsont.Object.mem "smartSearch" Jsont.bool ~enc:(fun r -> r.smart_search)
4951 |> Jsont.Object.mem "trash" Jsont.bool ~enc:(fun r -> r.trash)
4952 |> Jsont.Object.skip_unknown
4953 |> Jsont.Object.finish
4954 end
4955
4956 (** Get features
4957
4958 Retrieve available features supported by this server. *)
4959 let get_server_features client () =
4960 let op_name = "get_server_features" in
4961 let url_path = "/server/features" in
4962 let query = "" in
4963 let url = client.base_url ^ url_path ^ query in
4964 let response =
4965 try Requests.get client.session url
4966 with Eio.Io _ as ex ->
4967 let bt = Printexc.get_raw_backtrace () in
4968 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
4969 in
4970 if Requests.Response.ok response then
4971 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
4972 else
4973 let body = Requests.Response.text response in
4974 let parsed_body =
4975 match Jsont_bytesrw.decode_string Jsont.json body with
4976 | Ok json -> Some (Openapi.Runtime.Json json)
4977 | Error _ -> Some (Openapi.Runtime.Raw body)
4978 in
4979 raise (Openapi.Runtime.Api_error {
4980 operation = op_name;
4981 method_ = "GET";
4982 url;
4983 status = Requests.Response.status_code response;
4984 body;
4985 parsed_body;
4986 })
4987end
4988
4989module ServerConfig = struct
4990 module Types = struct
4991 module Dto = struct
4992 type t = {
4993 external_domain : string;
4994 is_initialized : bool;
4995 is_onboarded : bool;
4996 login_page_message : string;
4997 maintenance_mode : bool;
4998 map_dark_style_url : string;
4999 map_light_style_url : string;
5000 oauth_button_text : string;
5001 public_users : bool;
5002 trash_days : int;
5003 user_delete_delay : int;
5004 }
5005 end
5006 end
5007
5008 module Dto = struct
5009 include Types.Dto
5010
5011 let v ~external_domain ~is_initialized ~is_onboarded ~login_page_message ~maintenance_mode ~map_dark_style_url ~map_light_style_url ~oauth_button_text ~public_users ~trash_days ~user_delete_delay () = { external_domain; is_initialized; is_onboarded; login_page_message; maintenance_mode; map_dark_style_url; map_light_style_url; oauth_button_text; public_users; trash_days; user_delete_delay }
5012
5013 let external_domain t = t.external_domain
5014 let is_initialized t = t.is_initialized
5015 let is_onboarded t = t.is_onboarded
5016 let login_page_message t = t.login_page_message
5017 let maintenance_mode t = t.maintenance_mode
5018 let map_dark_style_url t = t.map_dark_style_url
5019 let map_light_style_url t = t.map_light_style_url
5020 let oauth_button_text t = t.oauth_button_text
5021 let public_users t = t.public_users
5022 let trash_days t = t.trash_days
5023 let user_delete_delay t = t.user_delete_delay
5024
5025 let jsont : t Jsont.t =
5026 Jsont.Object.map ~kind:"ServerConfigDto"
5027 (fun external_domain is_initialized is_onboarded login_page_message maintenance_mode map_dark_style_url map_light_style_url oauth_button_text public_users trash_days user_delete_delay -> { external_domain; is_initialized; is_onboarded; login_page_message; maintenance_mode; map_dark_style_url; map_light_style_url; oauth_button_text; public_users; trash_days; user_delete_delay })
5028 |> Jsont.Object.mem "externalDomain" Jsont.string ~enc:(fun r -> r.external_domain)
5029 |> Jsont.Object.mem "isInitialized" Jsont.bool ~enc:(fun r -> r.is_initialized)
5030 |> Jsont.Object.mem "isOnboarded" Jsont.bool ~enc:(fun r -> r.is_onboarded)
5031 |> Jsont.Object.mem "loginPageMessage" Jsont.string ~enc:(fun r -> r.login_page_message)
5032 |> Jsont.Object.mem "maintenanceMode" Jsont.bool ~enc:(fun r -> r.maintenance_mode)
5033 |> Jsont.Object.mem "mapDarkStyleUrl" Jsont.string ~enc:(fun r -> r.map_dark_style_url)
5034 |> Jsont.Object.mem "mapLightStyleUrl" Jsont.string ~enc:(fun r -> r.map_light_style_url)
5035 |> Jsont.Object.mem "oauthButtonText" Jsont.string ~enc:(fun r -> r.oauth_button_text)
5036 |> Jsont.Object.mem "publicUsers" Jsont.bool ~enc:(fun r -> r.public_users)
5037 |> Jsont.Object.mem "trashDays" Jsont.int ~enc:(fun r -> r.trash_days)
5038 |> Jsont.Object.mem "userDeleteDelay" Jsont.int ~enc:(fun r -> r.user_delete_delay)
5039 |> Jsont.Object.skip_unknown
5040 |> Jsont.Object.finish
5041 end
5042
5043 (** Get config
5044
5045 Retrieve the current server configuration. *)
5046 let get_server_config client () =
5047 let op_name = "get_server_config" in
5048 let url_path = "/server/config" in
5049 let query = "" in
5050 let url = client.base_url ^ url_path ^ query in
5051 let response =
5052 try Requests.get client.session url
5053 with Eio.Io _ as ex ->
5054 let bt = Printexc.get_raw_backtrace () in
5055 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5056 in
5057 if Requests.Response.ok response then
5058 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
5059 else
5060 let body = Requests.Response.text response in
5061 let parsed_body =
5062 match Jsont_bytesrw.decode_string Jsont.json body with
5063 | Ok json -> Some (Openapi.Runtime.Json json)
5064 | Error _ -> Some (Openapi.Runtime.Raw body)
5065 in
5066 raise (Openapi.Runtime.Api_error {
5067 operation = op_name;
5068 method_ = "GET";
5069 url;
5070 status = Requests.Response.status_code response;
5071 body;
5072 parsed_body;
5073 })
5074end
5075
5076module ServerApkLinks = struct
5077 module Types = struct
5078 module Dto = struct
5079 type t = {
5080 arm64v8a : string;
5081 armeabiv7a : string;
5082 universal : string;
5083 x86_64 : string;
5084 }
5085 end
5086 end
5087
5088 module Dto = struct
5089 include Types.Dto
5090
5091 let v ~arm64v8a ~armeabiv7a ~universal ~x86_64 () = { arm64v8a; armeabiv7a; universal; x86_64 }
5092
5093 let arm64v8a t = t.arm64v8a
5094 let armeabiv7a t = t.armeabiv7a
5095 let universal t = t.universal
5096 let x86_64 t = t.x86_64
5097
5098 let jsont : t Jsont.t =
5099 Jsont.Object.map ~kind:"ServerApkLinksDto"
5100 (fun arm64v8a armeabiv7a universal x86_64 -> { arm64v8a; armeabiv7a; universal; x86_64 })
5101 |> Jsont.Object.mem "arm64v8a" Jsont.string ~enc:(fun r -> r.arm64v8a)
5102 |> Jsont.Object.mem "armeabiv7a" Jsont.string ~enc:(fun r -> r.armeabiv7a)
5103 |> Jsont.Object.mem "universal" Jsont.string ~enc:(fun r -> r.universal)
5104 |> Jsont.Object.mem "x86_64" Jsont.string ~enc:(fun r -> r.x86_64)
5105 |> Jsont.Object.skip_unknown
5106 |> Jsont.Object.finish
5107 end
5108
5109 (** Get APK links
5110
5111 Retrieve links to the APKs for the current server version. *)
5112 let get_apk_links client () =
5113 let op_name = "get_apk_links" in
5114 let url_path = "/server/apk-links" in
5115 let query = "" in
5116 let url = client.base_url ^ url_path ^ query in
5117 let response =
5118 try Requests.get client.session url
5119 with Eio.Io _ as ex ->
5120 let bt = Printexc.get_raw_backtrace () in
5121 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5122 in
5123 if Requests.Response.ok response then
5124 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
5125 else
5126 let body = Requests.Response.text response in
5127 let parsed_body =
5128 match Jsont_bytesrw.decode_string Jsont.json body with
5129 | Ok json -> Some (Openapi.Runtime.Json json)
5130 | Error _ -> Some (Openapi.Runtime.Raw body)
5131 in
5132 raise (Openapi.Runtime.Api_error {
5133 operation = op_name;
5134 method_ = "GET";
5135 url;
5136 status = Requests.Response.status_code response;
5137 body;
5138 parsed_body;
5139 })
5140end
5141
5142module ServerAbout = struct
5143 module Types = struct
5144 module ResponseDto = struct
5145 type t = {
5146 build : string option;
5147 build_image : string option;
5148 build_image_url : string option;
5149 build_url : string option;
5150 exiftool : string option;
5151 ffmpeg : string option;
5152 imagemagick : string option;
5153 libvips : string option;
5154 licensed : bool;
5155 nodejs : string option;
5156 repository : string option;
5157 repository_url : string option;
5158 source_commit : string option;
5159 source_ref : string option;
5160 source_url : string option;
5161 third_party_bug_feature_url : string option;
5162 third_party_documentation_url : string option;
5163 third_party_source_url : string option;
5164 third_party_support_url : string option;
5165 version : string;
5166 version_url : string;
5167 }
5168 end
5169 end
5170
5171 module ResponseDto = struct
5172 include Types.ResponseDto
5173
5174 let v ~licensed ~version ~version_url ?build ?build_image ?build_image_url ?build_url ?exiftool ?ffmpeg ?imagemagick ?libvips ?nodejs ?repository ?repository_url ?source_commit ?source_ref ?source_url ?third_party_bug_feature_url ?third_party_documentation_url ?third_party_source_url ?third_party_support_url () = { build; build_image; build_image_url; build_url; exiftool; ffmpeg; imagemagick; libvips; licensed; nodejs; repository; repository_url; source_commit; source_ref; source_url; third_party_bug_feature_url; third_party_documentation_url; third_party_source_url; third_party_support_url; version; version_url }
5175
5176 let build t = t.build
5177 let build_image t = t.build_image
5178 let build_image_url t = t.build_image_url
5179 let build_url t = t.build_url
5180 let exiftool t = t.exiftool
5181 let ffmpeg t = t.ffmpeg
5182 let imagemagick t = t.imagemagick
5183 let libvips t = t.libvips
5184 let licensed t = t.licensed
5185 let nodejs t = t.nodejs
5186 let repository t = t.repository
5187 let repository_url t = t.repository_url
5188 let source_commit t = t.source_commit
5189 let source_ref t = t.source_ref
5190 let source_url t = t.source_url
5191 let third_party_bug_feature_url t = t.third_party_bug_feature_url
5192 let third_party_documentation_url t = t.third_party_documentation_url
5193 let third_party_source_url t = t.third_party_source_url
5194 let third_party_support_url t = t.third_party_support_url
5195 let version t = t.version
5196 let version_url t = t.version_url
5197
5198 let jsont : t Jsont.t =
5199 Jsont.Object.map ~kind:"ServerAboutResponseDto"
5200 (fun build build_image build_image_url build_url exiftool ffmpeg imagemagick libvips licensed nodejs repository repository_url source_commit source_ref source_url third_party_bug_feature_url third_party_documentation_url third_party_source_url third_party_support_url version version_url -> { build; build_image; build_image_url; build_url; exiftool; ffmpeg; imagemagick; libvips; licensed; nodejs; repository; repository_url; source_commit; source_ref; source_url; third_party_bug_feature_url; third_party_documentation_url; third_party_source_url; third_party_support_url; version; version_url })
5201 |> Jsont.Object.opt_mem "build" Jsont.string ~enc:(fun r -> r.build)
5202 |> Jsont.Object.opt_mem "buildImage" Jsont.string ~enc:(fun r -> r.build_image)
5203 |> Jsont.Object.opt_mem "buildImageUrl" Jsont.string ~enc:(fun r -> r.build_image_url)
5204 |> Jsont.Object.opt_mem "buildUrl" Jsont.string ~enc:(fun r -> r.build_url)
5205 |> Jsont.Object.opt_mem "exiftool" Jsont.string ~enc:(fun r -> r.exiftool)
5206 |> Jsont.Object.opt_mem "ffmpeg" Jsont.string ~enc:(fun r -> r.ffmpeg)
5207 |> Jsont.Object.opt_mem "imagemagick" Jsont.string ~enc:(fun r -> r.imagemagick)
5208 |> Jsont.Object.opt_mem "libvips" Jsont.string ~enc:(fun r -> r.libvips)
5209 |> Jsont.Object.mem "licensed" Jsont.bool ~enc:(fun r -> r.licensed)
5210 |> Jsont.Object.opt_mem "nodejs" Jsont.string ~enc:(fun r -> r.nodejs)
5211 |> Jsont.Object.opt_mem "repository" Jsont.string ~enc:(fun r -> r.repository)
5212 |> Jsont.Object.opt_mem "repositoryUrl" Jsont.string ~enc:(fun r -> r.repository_url)
5213 |> Jsont.Object.opt_mem "sourceCommit" Jsont.string ~enc:(fun r -> r.source_commit)
5214 |> Jsont.Object.opt_mem "sourceRef" Jsont.string ~enc:(fun r -> r.source_ref)
5215 |> Jsont.Object.opt_mem "sourceUrl" Jsont.string ~enc:(fun r -> r.source_url)
5216 |> Jsont.Object.opt_mem "thirdPartyBugFeatureUrl" Jsont.string ~enc:(fun r -> r.third_party_bug_feature_url)
5217 |> Jsont.Object.opt_mem "thirdPartyDocumentationUrl" Jsont.string ~enc:(fun r -> r.third_party_documentation_url)
5218 |> Jsont.Object.opt_mem "thirdPartySourceUrl" Jsont.string ~enc:(fun r -> r.third_party_source_url)
5219 |> Jsont.Object.opt_mem "thirdPartySupportUrl" Jsont.string ~enc:(fun r -> r.third_party_support_url)
5220 |> Jsont.Object.mem "version" Jsont.string ~enc:(fun r -> r.version)
5221 |> Jsont.Object.mem "versionUrl" Jsont.string ~enc:(fun r -> r.version_url)
5222 |> Jsont.Object.skip_unknown
5223 |> Jsont.Object.finish
5224 end
5225
5226 (** Get server information
5227
5228 Retrieve a list of information about the server. *)
5229 let get_about_info client () =
5230 let op_name = "get_about_info" in
5231 let url_path = "/server/about" in
5232 let query = "" in
5233 let url = client.base_url ^ url_path ^ query in
5234 let response =
5235 try Requests.get client.session url
5236 with Eio.Io _ as ex ->
5237 let bt = Printexc.get_raw_backtrace () in
5238 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5239 in
5240 if Requests.Response.ok response then
5241 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5242 else
5243 let body = Requests.Response.text response in
5244 let parsed_body =
5245 match Jsont_bytesrw.decode_string Jsont.json body with
5246 | Ok json -> Some (Openapi.Runtime.Json json)
5247 | Error _ -> Some (Openapi.Runtime.Raw body)
5248 in
5249 raise (Openapi.Runtime.Api_error {
5250 operation = op_name;
5251 method_ = "GET";
5252 url;
5253 status = Requests.Response.status_code response;
5254 body;
5255 parsed_body;
5256 })
5257end
5258
5259module SearchSuggestion = struct
5260 module Types = struct
5261 module Type = struct
5262 type t = [
5263 | `Country
5264 | `State
5265 | `City
5266 | `Camera_make
5267 | `Camera_model
5268 | `Camera_lens_model
5269 ]
5270 end
5271 end
5272
5273 module Type = struct
5274 include Types.Type
5275
5276 let jsont : t Jsont.t =
5277 Jsont.map Jsont.string ~kind:"SearchSuggestionType"
5278 ~dec:(function
5279 | "country" -> `Country
5280 | "state" -> `State
5281 | "city" -> `City
5282 | "camera-make" -> `Camera_make
5283 | "camera-model" -> `Camera_model
5284 | "camera-lens-model" -> `Camera_lens_model
5285 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
5286 ~enc:(function
5287 | `Country -> "country"
5288 | `State -> "state"
5289 | `City -> "city"
5290 | `Camera_make -> "camera-make"
5291 | `Camera_model -> "camera-model"
5292 | `Camera_lens_model -> "camera-lens-model")
5293 end
5294end
5295
5296module SearchFacetCount = struct
5297 module Types = struct
5298 module ResponseDto = struct
5299 type t = {
5300 count : int;
5301 value : string;
5302 }
5303 end
5304 end
5305
5306 module ResponseDto = struct
5307 include Types.ResponseDto
5308
5309 let v ~count ~value () = { count; value }
5310
5311 let count t = t.count
5312 let value t = t.value
5313
5314 let jsont : t Jsont.t =
5315 Jsont.Object.map ~kind:"SearchFacetCountResponseDto"
5316 (fun count value -> { count; value })
5317 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
5318 |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
5319 |> Jsont.Object.skip_unknown
5320 |> Jsont.Object.finish
5321 end
5322end
5323
5324module SearchFacet = struct
5325 module Types = struct
5326 module ResponseDto = struct
5327 type t = {
5328 counts : SearchFacetCount.ResponseDto.t list;
5329 field_name : string;
5330 }
5331 end
5332 end
5333
5334 module ResponseDto = struct
5335 include Types.ResponseDto
5336
5337 let v ~counts ~field_name () = { counts; field_name }
5338
5339 let counts t = t.counts
5340 let field_name t = t.field_name
5341
5342 let jsont : t Jsont.t =
5343 Jsont.Object.map ~kind:"SearchFacetResponseDto"
5344 (fun counts field_name -> { counts; field_name })
5345 |> Jsont.Object.mem "counts" (Jsont.list SearchFacetCount.ResponseDto.jsont) ~enc:(fun r -> r.counts)
5346 |> Jsont.Object.mem "fieldName" Jsont.string ~enc:(fun r -> r.field_name)
5347 |> Jsont.Object.skip_unknown
5348 |> Jsont.Object.finish
5349 end
5350end
5351
5352module RotateParameters = struct
5353 module Types = struct
5354 module T = struct
5355 type t = {
5356 angle : float; (** Rotation angle in degrees *)
5357 }
5358 end
5359 end
5360
5361 module T = struct
5362 include Types.T
5363
5364 let v ~angle () = { angle }
5365
5366 let angle t = t.angle
5367
5368 let jsont : t Jsont.t =
5369 Jsont.Object.map ~kind:"RotateParameters"
5370 (fun angle -> { angle })
5371 |> Jsont.Object.mem "angle" Jsont.number ~enc:(fun r -> r.angle)
5372 |> Jsont.Object.skip_unknown
5373 |> Jsont.Object.finish
5374 end
5375end
5376
5377module ReverseGeocodingState = struct
5378 module Types = struct
5379 module ResponseDto = struct
5380 type t = {
5381 last_import_file_name : string option;
5382 last_update : string option;
5383 }
5384 end
5385 end
5386
5387 module ResponseDto = struct
5388 include Types.ResponseDto
5389
5390 let v ?last_import_file_name ?last_update () = { last_import_file_name; last_update }
5391
5392 let last_import_file_name t = t.last_import_file_name
5393 let last_update t = t.last_update
5394
5395 let jsont : t Jsont.t =
5396 Jsont.Object.map ~kind:"ReverseGeocodingStateResponseDto"
5397 (fun last_import_file_name last_update -> { last_import_file_name; last_update })
5398 |> Jsont.Object.mem "lastImportFileName" Openapi.Runtime.nullable_string
5399 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.last_import_file_name)
5400 |> Jsont.Object.mem "lastUpdate" Openapi.Runtime.nullable_string
5401 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.last_update)
5402 |> Jsont.Object.skip_unknown
5403 |> Jsont.Object.finish
5404 end
5405
5406 (** Retrieve reverse geocoding state
5407
5408 Retrieve the current state of the reverse geocoding import. *)
5409 let get_reverse_geocoding_state client () =
5410 let op_name = "get_reverse_geocoding_state" in
5411 let url_path = "/system-metadata/reverse-geocoding-state" in
5412 let query = "" in
5413 let url = client.base_url ^ url_path ^ query in
5414 let response =
5415 try Requests.get client.session url
5416 with Eio.Io _ as ex ->
5417 let bt = Printexc.get_raw_backtrace () in
5418 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5419 in
5420 if Requests.Response.ok response then
5421 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5422 else
5423 let body = Requests.Response.text response in
5424 let parsed_body =
5425 match Jsont_bytesrw.decode_string Jsont.json body with
5426 | Ok json -> Some (Openapi.Runtime.Json json)
5427 | Error _ -> Some (Openapi.Runtime.Raw body)
5428 in
5429 raise (Openapi.Runtime.Api_error {
5430 operation = op_name;
5431 method_ = "GET";
5432 url;
5433 status = Requests.Response.status_code response;
5434 body;
5435 parsed_body;
5436 })
5437end
5438
5439module ReactionLevel = struct
5440 module Types = struct
5441 module T = struct
5442 type t = [
5443 | `Album
5444 | `Asset
5445 ]
5446 end
5447 end
5448
5449 module T = struct
5450 include Types.T
5451
5452 let jsont : t Jsont.t =
5453 Jsont.map Jsont.string ~kind:"ReactionLevel"
5454 ~dec:(function
5455 | "album" -> `Album
5456 | "asset" -> `Asset
5457 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
5458 ~enc:(function
5459 | `Album -> "album"
5460 | `Asset -> "asset")
5461 end
5462end
5463
5464module Reaction = struct
5465 module Types = struct
5466 module Type = struct
5467 type t = [
5468 | `Comment
5469 | `Like
5470 ]
5471 end
5472 end
5473
5474 module Type = struct
5475 include Types.Type
5476
5477 let jsont : t Jsont.t =
5478 Jsont.map Jsont.string ~kind:"ReactionType"
5479 ~dec:(function
5480 | "comment" -> `Comment
5481 | "like" -> `Like
5482 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
5483 ~enc:(function
5484 | `Comment -> "comment"
5485 | `Like -> "like")
5486 end
5487end
5488
5489module Activity = struct
5490 module Types = struct
5491 module ResponseDto = struct
5492 type t = {
5493 asset_id : string option;
5494 comment : string option;
5495 created_at : Ptime.t;
5496 id : string;
5497 type_ : Reaction.Type.t;
5498 user : User.ResponseDto.t;
5499 }
5500 end
5501
5502 module CreateDto = struct
5503 type t = {
5504 album_id : string;
5505 asset_id : string option;
5506 comment : string option;
5507 type_ : Reaction.Type.t;
5508 }
5509 end
5510 end
5511
5512 module ResponseDto = struct
5513 include Types.ResponseDto
5514
5515 let v ~created_at ~id ~type_ ~user ?asset_id ?comment () = { asset_id; comment; created_at; id; type_; user }
5516
5517 let asset_id t = t.asset_id
5518 let comment t = t.comment
5519 let created_at t = t.created_at
5520 let id t = t.id
5521 let type_ t = t.type_
5522 let user t = t.user
5523
5524 let jsont : t Jsont.t =
5525 Jsont.Object.map ~kind:"ActivityResponseDto"
5526 (fun asset_id comment created_at id type_ user -> { asset_id; comment; created_at; id; type_; user })
5527 |> Jsont.Object.mem "assetId" Openapi.Runtime.nullable_string
5528 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.asset_id)
5529 |> Jsont.Object.mem "comment" Openapi.Runtime.nullable_string
5530 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.comment)
5531 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
5532 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
5533 |> Jsont.Object.mem "type" Reaction.Type.jsont ~enc:(fun r -> r.type_)
5534 |> Jsont.Object.mem "user" User.ResponseDto.jsont ~enc:(fun r -> r.user)
5535 |> Jsont.Object.skip_unknown
5536 |> Jsont.Object.finish
5537 end
5538
5539 module CreateDto = struct
5540 include Types.CreateDto
5541
5542 let v ~album_id ~type_ ?asset_id ?comment () = { album_id; asset_id; comment; type_ }
5543
5544 let album_id t = t.album_id
5545 let asset_id t = t.asset_id
5546 let comment t = t.comment
5547 let type_ t = t.type_
5548
5549 let jsont : t Jsont.t =
5550 Jsont.Object.map ~kind:"ActivityCreateDto"
5551 (fun album_id asset_id comment type_ -> { album_id; asset_id; comment; type_ })
5552 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
5553 |> Jsont.Object.opt_mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
5554 |> Jsont.Object.opt_mem "comment" Jsont.string ~enc:(fun r -> r.comment)
5555 |> Jsont.Object.mem "type" Reaction.Type.jsont ~enc:(fun r -> r.type_)
5556 |> Jsont.Object.skip_unknown
5557 |> Jsont.Object.finish
5558 end
5559
5560 (** List all activities
5561
5562 Returns a list of activities for the selected asset or album. The activities are returned in sorted order, with the oldest activities appearing first. *)
5563 let get_activities ~album_id ?asset_id ?level ?type_ ?user_id client () =
5564 let op_name = "get_activities" in
5565 let url_path = "/activities" in
5566 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"albumId" ~value:album_id; Openapi.Runtime.Query.optional ~key:"assetId" ~value:asset_id; Openapi.Runtime.Query.optional ~key:"level" ~value:level; Openapi.Runtime.Query.optional ~key:"type" ~value:type_; Openapi.Runtime.Query.optional ~key:"userId" ~value:user_id]) in
5567 let url = client.base_url ^ url_path ^ query in
5568 let response =
5569 try Requests.get client.session url
5570 with Eio.Io _ as ex ->
5571 let bt = Printexc.get_raw_backtrace () in
5572 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5573 in
5574 if Requests.Response.ok response then
5575 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5576 else
5577 let body = Requests.Response.text response in
5578 let parsed_body =
5579 match Jsont_bytesrw.decode_string Jsont.json body with
5580 | Ok json -> Some (Openapi.Runtime.Json json)
5581 | Error _ -> Some (Openapi.Runtime.Raw body)
5582 in
5583 raise (Openapi.Runtime.Api_error {
5584 operation = op_name;
5585 method_ = "GET";
5586 url;
5587 status = Requests.Response.status_code response;
5588 body;
5589 parsed_body;
5590 })
5591
5592 (** Create an activity
5593
5594 Create a like or a comment for an album, or an asset in an album. *)
5595 let create_activity ~body client () =
5596 let op_name = "create_activity" in
5597 let url_path = "/activities" in
5598 let query = "" in
5599 let url = client.base_url ^ url_path ^ query in
5600 let response =
5601 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
5602 with Eio.Io _ as ex ->
5603 let bt = Printexc.get_raw_backtrace () in
5604 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
5605 in
5606 if Requests.Response.ok response then
5607 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5608 else
5609 let body = Requests.Response.text response in
5610 let parsed_body =
5611 match Jsont_bytesrw.decode_string Jsont.json body with
5612 | Ok json -> Some (Openapi.Runtime.Json json)
5613 | Error _ -> Some (Openapi.Runtime.Raw body)
5614 in
5615 raise (Openapi.Runtime.Api_error {
5616 operation = op_name;
5617 method_ = "POST";
5618 url;
5619 status = Requests.Response.status_code response;
5620 body;
5621 parsed_body;
5622 })
5623end
5624
5625module Ratings = struct
5626 module Types = struct
5627 module Update = struct
5628 type t = {
5629 enabled : bool option;
5630 }
5631 end
5632
5633 module Response = struct
5634 type t = {
5635 enabled : bool;
5636 }
5637 end
5638 end
5639
5640 module Update = struct
5641 include Types.Update
5642
5643 let v ?enabled () = { enabled }
5644
5645 let enabled t = t.enabled
5646
5647 let jsont : t Jsont.t =
5648 Jsont.Object.map ~kind:"RatingsUpdate"
5649 (fun enabled -> { enabled })
5650 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
5651 |> Jsont.Object.skip_unknown
5652 |> Jsont.Object.finish
5653 end
5654
5655 module Response = struct
5656 include Types.Response
5657
5658 let v ?(enabled=false) () = { enabled }
5659
5660 let enabled t = t.enabled
5661
5662 let jsont : t Jsont.t =
5663 Jsont.Object.map ~kind:"RatingsResponse"
5664 (fun enabled -> { enabled })
5665 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.enabled)
5666 |> Jsont.Object.skip_unknown
5667 |> Jsont.Object.finish
5668 end
5669end
5670
5671module QueueStatusLegacy = struct
5672 module Types = struct
5673 module Dto = struct
5674 type t = {
5675 is_active : bool;
5676 is_paused : bool;
5677 }
5678 end
5679 end
5680
5681 module Dto = struct
5682 include Types.Dto
5683
5684 let v ~is_active ~is_paused () = { is_active; is_paused }
5685
5686 let is_active t = t.is_active
5687 let is_paused t = t.is_paused
5688
5689 let jsont : t Jsont.t =
5690 Jsont.Object.map ~kind:"QueueStatusLegacyDto"
5691 (fun is_active is_paused -> { is_active; is_paused })
5692 |> Jsont.Object.mem "isActive" Jsont.bool ~enc:(fun r -> r.is_active)
5693 |> Jsont.Object.mem "isPaused" Jsont.bool ~enc:(fun r -> r.is_paused)
5694 |> Jsont.Object.skip_unknown
5695 |> Jsont.Object.finish
5696 end
5697end
5698
5699module QueueStatistics = struct
5700 module Types = struct
5701 module Dto = struct
5702 type t = {
5703 active : int;
5704 completed : int;
5705 delayed : int;
5706 failed : int;
5707 paused : int;
5708 waiting : int;
5709 }
5710 end
5711 end
5712
5713 module Dto = struct
5714 include Types.Dto
5715
5716 let v ~active ~completed ~delayed ~failed ~paused ~waiting () = { active; completed; delayed; failed; paused; waiting }
5717
5718 let active t = t.active
5719 let completed t = t.completed
5720 let delayed t = t.delayed
5721 let failed t = t.failed
5722 let paused t = t.paused
5723 let waiting t = t.waiting
5724
5725 let jsont : t Jsont.t =
5726 Jsont.Object.map ~kind:"QueueStatisticsDto"
5727 (fun active completed delayed failed paused waiting -> { active; completed; delayed; failed; paused; waiting })
5728 |> Jsont.Object.mem "active" Jsont.int ~enc:(fun r -> r.active)
5729 |> Jsont.Object.mem "completed" Jsont.int ~enc:(fun r -> r.completed)
5730 |> Jsont.Object.mem "delayed" Jsont.int ~enc:(fun r -> r.delayed)
5731 |> Jsont.Object.mem "failed" Jsont.int ~enc:(fun r -> r.failed)
5732 |> Jsont.Object.mem "paused" Jsont.int ~enc:(fun r -> r.paused)
5733 |> Jsont.Object.mem "waiting" Jsont.int ~enc:(fun r -> r.waiting)
5734 |> Jsont.Object.skip_unknown
5735 |> Jsont.Object.finish
5736 end
5737end
5738
5739module QueueName = struct
5740 module Types = struct
5741 module T = struct
5742 type t = [
5743 | `Thumbnail_generation
5744 | `Metadata_extraction
5745 | `Video_conversion
5746 | `Face_detection
5747 | `Facial_recognition
5748 | `Smart_search
5749 | `Duplicate_detection
5750 | `Background_task
5751 | `Storage_template_migration
5752 | `Migration
5753 | `Search
5754 | `Sidecar
5755 | `Library
5756 | `Notifications
5757 | `Backup_database
5758 | `Ocr
5759 | `Workflow
5760 | `Editor
5761 ]
5762 end
5763 end
5764
5765 module T = struct
5766 include Types.T
5767
5768 let jsont : t Jsont.t =
5769 Jsont.map Jsont.string ~kind:"QueueName"
5770 ~dec:(function
5771 | "thumbnailGeneration" -> `Thumbnail_generation
5772 | "metadataExtraction" -> `Metadata_extraction
5773 | "videoConversion" -> `Video_conversion
5774 | "faceDetection" -> `Face_detection
5775 | "facialRecognition" -> `Facial_recognition
5776 | "smartSearch" -> `Smart_search
5777 | "duplicateDetection" -> `Duplicate_detection
5778 | "backgroundTask" -> `Background_task
5779 | "storageTemplateMigration" -> `Storage_template_migration
5780 | "migration" -> `Migration
5781 | "search" -> `Search
5782 | "sidecar" -> `Sidecar
5783 | "library" -> `Library
5784 | "notifications" -> `Notifications
5785 | "backupDatabase" -> `Backup_database
5786 | "ocr" -> `Ocr
5787 | "workflow" -> `Workflow
5788 | "editor" -> `Editor
5789 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
5790 ~enc:(function
5791 | `Thumbnail_generation -> "thumbnailGeneration"
5792 | `Metadata_extraction -> "metadataExtraction"
5793 | `Video_conversion -> "videoConversion"
5794 | `Face_detection -> "faceDetection"
5795 | `Facial_recognition -> "facialRecognition"
5796 | `Smart_search -> "smartSearch"
5797 | `Duplicate_detection -> "duplicateDetection"
5798 | `Background_task -> "backgroundTask"
5799 | `Storage_template_migration -> "storageTemplateMigration"
5800 | `Migration -> "migration"
5801 | `Search -> "search"
5802 | `Sidecar -> "sidecar"
5803 | `Library -> "library"
5804 | `Notifications -> "notifications"
5805 | `Backup_database -> "backupDatabase"
5806 | `Ocr -> "ocr"
5807 | `Workflow -> "workflow"
5808 | `Editor -> "editor")
5809 end
5810end
5811
5812module Queue = struct
5813 module Types = struct
5814 module UpdateDto = struct
5815 type t = {
5816 is_paused : bool option;
5817 }
5818 end
5819
5820 module ResponseDto = struct
5821 type t = {
5822 is_paused : bool;
5823 name : QueueName.T.t;
5824 statistics : QueueStatistics.Dto.t;
5825 }
5826 end
5827 end
5828
5829 module UpdateDto = struct
5830 include Types.UpdateDto
5831
5832 let v ?is_paused () = { is_paused }
5833
5834 let is_paused t = t.is_paused
5835
5836 let jsont : t Jsont.t =
5837 Jsont.Object.map ~kind:"QueueUpdateDto"
5838 (fun is_paused -> { is_paused })
5839 |> Jsont.Object.opt_mem "isPaused" Jsont.bool ~enc:(fun r -> r.is_paused)
5840 |> Jsont.Object.skip_unknown
5841 |> Jsont.Object.finish
5842 end
5843
5844 module ResponseDto = struct
5845 include Types.ResponseDto
5846
5847 let v ~is_paused ~name ~statistics () = { is_paused; name; statistics }
5848
5849 let is_paused t = t.is_paused
5850 let name t = t.name
5851 let statistics t = t.statistics
5852
5853 let jsont : t Jsont.t =
5854 Jsont.Object.map ~kind:"QueueResponseDto"
5855 (fun is_paused name statistics -> { is_paused; name; statistics })
5856 |> Jsont.Object.mem "isPaused" Jsont.bool ~enc:(fun r -> r.is_paused)
5857 |> Jsont.Object.mem "name" QueueName.T.jsont ~enc:(fun r -> r.name)
5858 |> Jsont.Object.mem "statistics" QueueStatistics.Dto.jsont ~enc:(fun r -> r.statistics)
5859 |> Jsont.Object.skip_unknown
5860 |> Jsont.Object.finish
5861 end
5862
5863 (** List all queues
5864
5865 Retrieves a list of queues. *)
5866 let get_queues client () =
5867 let op_name = "get_queues" in
5868 let url_path = "/queues" in
5869 let query = "" in
5870 let url = client.base_url ^ url_path ^ query in
5871 let response =
5872 try Requests.get client.session url
5873 with Eio.Io _ as ex ->
5874 let bt = Printexc.get_raw_backtrace () in
5875 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5876 in
5877 if Requests.Response.ok response then
5878 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5879 else
5880 let body = Requests.Response.text response in
5881 let parsed_body =
5882 match Jsont_bytesrw.decode_string Jsont.json body with
5883 | Ok json -> Some (Openapi.Runtime.Json json)
5884 | Error _ -> Some (Openapi.Runtime.Raw body)
5885 in
5886 raise (Openapi.Runtime.Api_error {
5887 operation = op_name;
5888 method_ = "GET";
5889 url;
5890 status = Requests.Response.status_code response;
5891 body;
5892 parsed_body;
5893 })
5894
5895 (** Retrieve a queue
5896
5897 Retrieves a specific queue by its name. *)
5898 let get_queue ~name client () =
5899 let op_name = "get_queue" in
5900 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/queues/{name}" in
5901 let query = "" in
5902 let url = client.base_url ^ url_path ^ query in
5903 let response =
5904 try Requests.get client.session url
5905 with Eio.Io _ as ex ->
5906 let bt = Printexc.get_raw_backtrace () in
5907 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
5908 in
5909 if Requests.Response.ok response then
5910 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5911 else
5912 let body = Requests.Response.text response in
5913 let parsed_body =
5914 match Jsont_bytesrw.decode_string Jsont.json body with
5915 | Ok json -> Some (Openapi.Runtime.Json json)
5916 | Error _ -> Some (Openapi.Runtime.Raw body)
5917 in
5918 raise (Openapi.Runtime.Api_error {
5919 operation = op_name;
5920 method_ = "GET";
5921 url;
5922 status = Requests.Response.status_code response;
5923 body;
5924 parsed_body;
5925 })
5926
5927 (** Update a queue
5928
5929 Change the paused status of a specific queue. *)
5930 let update_queue ~name ~body client () =
5931 let op_name = "update_queue" in
5932 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/queues/{name}" in
5933 let query = "" in
5934 let url = client.base_url ^ url_path ^ query in
5935 let response =
5936 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
5937 with Eio.Io _ as ex ->
5938 let bt = Printexc.get_raw_backtrace () in
5939 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
5940 in
5941 if Requests.Response.ok response then
5942 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
5943 else
5944 let body = Requests.Response.text response in
5945 let parsed_body =
5946 match Jsont_bytesrw.decode_string Jsont.json body with
5947 | Ok json -> Some (Openapi.Runtime.Json json)
5948 | Error _ -> Some (Openapi.Runtime.Raw body)
5949 in
5950 raise (Openapi.Runtime.Api_error {
5951 operation = op_name;
5952 method_ = "PUT";
5953 url;
5954 status = Requests.Response.status_code response;
5955 body;
5956 parsed_body;
5957 })
5958end
5959
5960module QueueDelete = struct
5961 module Types = struct
5962 module Dto = struct
5963 type t = {
5964 failed : bool option; (** If true, will also remove failed jobs from the queue. *)
5965 }
5966 end
5967 end
5968
5969 module Dto = struct
5970 include Types.Dto
5971
5972 let v ?failed () = { failed }
5973
5974 let failed t = t.failed
5975
5976 let jsont : t Jsont.t =
5977 Jsont.Object.map ~kind:"QueueDeleteDto"
5978 (fun failed -> { failed })
5979 |> Jsont.Object.opt_mem "failed" Jsont.bool ~enc:(fun r -> r.failed)
5980 |> Jsont.Object.skip_unknown
5981 |> Jsont.Object.finish
5982 end
5983end
5984
5985module QueueCommand = struct
5986 module Types = struct
5987 module T = struct
5988 type t = [
5989 | `Start
5990 | `Pause
5991 | `Resume
5992 | `Empty
5993 | `Clear_failed
5994 ]
5995 end
5996
5997 module Dto = struct
5998 type t = {
5999 command : T.t;
6000 force : bool option;
6001 }
6002 end
6003 end
6004
6005 module T = struct
6006 include Types.T
6007
6008 let jsont : t Jsont.t =
6009 Jsont.map Jsont.string ~kind:"QueueCommand"
6010 ~dec:(function
6011 | "start" -> `Start
6012 | "pause" -> `Pause
6013 | "resume" -> `Resume
6014 | "empty" -> `Empty
6015 | "clear-failed" -> `Clear_failed
6016 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
6017 ~enc:(function
6018 | `Start -> "start"
6019 | `Pause -> "pause"
6020 | `Resume -> "resume"
6021 | `Empty -> "empty"
6022 | `Clear_failed -> "clear-failed")
6023 end
6024
6025 module Dto = struct
6026 include Types.Dto
6027
6028 let v ~command ?force () = { command; force }
6029
6030 let command t = t.command
6031 let force t = t.force
6032
6033 let jsont : t Jsont.t =
6034 Jsont.Object.map ~kind:"QueueCommandDto"
6035 (fun command force -> { command; force })
6036 |> Jsont.Object.mem "command" T.jsont ~enc:(fun r -> r.command)
6037 |> Jsont.Object.opt_mem "force" Jsont.bool ~enc:(fun r -> r.force)
6038 |> Jsont.Object.skip_unknown
6039 |> Jsont.Object.finish
6040 end
6041end
6042
6043module QueueResponseLegacy = struct
6044 module Types = struct
6045 module Dto = struct
6046 type t = {
6047 job_counts : QueueStatistics.Dto.t;
6048 queue_status : QueueStatusLegacy.Dto.t;
6049 }
6050 end
6051 end
6052
6053 module Dto = struct
6054 include Types.Dto
6055
6056 let v ~job_counts ~queue_status () = { job_counts; queue_status }
6057
6058 let job_counts t = t.job_counts
6059 let queue_status t = t.queue_status
6060
6061 let jsont : t Jsont.t =
6062 Jsont.Object.map ~kind:"QueueResponseLegacyDto"
6063 (fun job_counts queue_status -> { job_counts; queue_status })
6064 |> Jsont.Object.mem "jobCounts" QueueStatistics.Dto.jsont ~enc:(fun r -> r.job_counts)
6065 |> Jsont.Object.mem "queueStatus" QueueStatusLegacy.Dto.jsont ~enc:(fun r -> r.queue_status)
6066 |> Jsont.Object.skip_unknown
6067 |> Jsont.Object.finish
6068 end
6069
6070 (** Run jobs
6071
6072 Queue all assets for a specific job type. Defaults to only queueing assets that have not yet been processed, but the force command can be used to re-process all assets. *)
6073 let run_queue_command_legacy ~name ~body client () =
6074 let op_name = "run_queue_command_legacy" in
6075 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/jobs/{name}" in
6076 let query = "" in
6077 let url = client.base_url ^ url_path ^ query in
6078 let response =
6079 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json QueueCommand.Dto.jsont body)) url
6080 with Eio.Io _ as ex ->
6081 let bt = Printexc.get_raw_backtrace () in
6082 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
6083 in
6084 if Requests.Response.ok response then
6085 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
6086 else
6087 let body = Requests.Response.text response in
6088 let parsed_body =
6089 match Jsont_bytesrw.decode_string Jsont.json body with
6090 | Ok json -> Some (Openapi.Runtime.Json json)
6091 | Error _ -> Some (Openapi.Runtime.Raw body)
6092 in
6093 raise (Openapi.Runtime.Api_error {
6094 operation = op_name;
6095 method_ = "PUT";
6096 url;
6097 status = Requests.Response.status_code response;
6098 body;
6099 parsed_body;
6100 })
6101end
6102
6103module QueuesResponseLegacy = struct
6104 module Types = struct
6105 module Dto = struct
6106 type t = {
6107 background_task : QueueResponseLegacy.Dto.t;
6108 backup_database : QueueResponseLegacy.Dto.t;
6109 duplicate_detection : QueueResponseLegacy.Dto.t;
6110 editor : QueueResponseLegacy.Dto.t;
6111 face_detection : QueueResponseLegacy.Dto.t;
6112 facial_recognition : QueueResponseLegacy.Dto.t;
6113 library : QueueResponseLegacy.Dto.t;
6114 metadata_extraction : QueueResponseLegacy.Dto.t;
6115 migration : QueueResponseLegacy.Dto.t;
6116 notifications : QueueResponseLegacy.Dto.t;
6117 ocr : QueueResponseLegacy.Dto.t;
6118 search : QueueResponseLegacy.Dto.t;
6119 sidecar : QueueResponseLegacy.Dto.t;
6120 smart_search : QueueResponseLegacy.Dto.t;
6121 storage_template_migration : QueueResponseLegacy.Dto.t;
6122 thumbnail_generation : QueueResponseLegacy.Dto.t;
6123 video_conversion : QueueResponseLegacy.Dto.t;
6124 workflow : QueueResponseLegacy.Dto.t;
6125 }
6126 end
6127 end
6128
6129 module Dto = struct
6130 include Types.Dto
6131
6132 let v ~background_task ~backup_database ~duplicate_detection ~editor ~face_detection ~facial_recognition ~library ~metadata_extraction ~migration ~notifications ~ocr ~search ~sidecar ~smart_search ~storage_template_migration ~thumbnail_generation ~video_conversion ~workflow () = { background_task; backup_database; duplicate_detection; editor; face_detection; facial_recognition; library; metadata_extraction; migration; notifications; ocr; search; sidecar; smart_search; storage_template_migration; thumbnail_generation; video_conversion; workflow }
6133
6134 let background_task t = t.background_task
6135 let backup_database t = t.backup_database
6136 let duplicate_detection t = t.duplicate_detection
6137 let editor t = t.editor
6138 let face_detection t = t.face_detection
6139 let facial_recognition t = t.facial_recognition
6140 let library t = t.library
6141 let metadata_extraction t = t.metadata_extraction
6142 let migration t = t.migration
6143 let notifications t = t.notifications
6144 let ocr t = t.ocr
6145 let search t = t.search
6146 let sidecar t = t.sidecar
6147 let smart_search t = t.smart_search
6148 let storage_template_migration t = t.storage_template_migration
6149 let thumbnail_generation t = t.thumbnail_generation
6150 let video_conversion t = t.video_conversion
6151 let workflow t = t.workflow
6152
6153 let jsont : t Jsont.t =
6154 Jsont.Object.map ~kind:"QueuesResponseLegacyDto"
6155 (fun background_task backup_database duplicate_detection editor face_detection facial_recognition library metadata_extraction migration notifications ocr search sidecar smart_search storage_template_migration thumbnail_generation video_conversion workflow -> { background_task; backup_database; duplicate_detection; editor; face_detection; facial_recognition; library; metadata_extraction; migration; notifications; ocr; search; sidecar; smart_search; storage_template_migration; thumbnail_generation; video_conversion; workflow })
6156 |> Jsont.Object.mem "backgroundTask" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.background_task)
6157 |> Jsont.Object.mem "backupDatabase" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.backup_database)
6158 |> Jsont.Object.mem "duplicateDetection" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.duplicate_detection)
6159 |> Jsont.Object.mem "editor" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.editor)
6160 |> Jsont.Object.mem "faceDetection" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.face_detection)
6161 |> Jsont.Object.mem "facialRecognition" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.facial_recognition)
6162 |> Jsont.Object.mem "library" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.library)
6163 |> Jsont.Object.mem "metadataExtraction" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.metadata_extraction)
6164 |> Jsont.Object.mem "migration" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.migration)
6165 |> Jsont.Object.mem "notifications" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.notifications)
6166 |> Jsont.Object.mem "ocr" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.ocr)
6167 |> Jsont.Object.mem "search" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.search)
6168 |> Jsont.Object.mem "sidecar" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.sidecar)
6169 |> Jsont.Object.mem "smartSearch" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.smart_search)
6170 |> Jsont.Object.mem "storageTemplateMigration" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.storage_template_migration)
6171 |> Jsont.Object.mem "thumbnailGeneration" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.thumbnail_generation)
6172 |> Jsont.Object.mem "videoConversion" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.video_conversion)
6173 |> Jsont.Object.mem "workflow" QueueResponseLegacy.Dto.jsont ~enc:(fun r -> r.workflow)
6174 |> Jsont.Object.skip_unknown
6175 |> Jsont.Object.finish
6176 end
6177
6178 (** Retrieve queue counts and status
6179
6180 Retrieve the counts of the current queue, as well as the current status. *)
6181 let get_queues_legacy client () =
6182 let op_name = "get_queues_legacy" in
6183 let url_path = "/jobs" in
6184 let query = "" in
6185 let url = client.base_url ^ url_path ^ query in
6186 let response =
6187 try Requests.get client.session url
6188 with Eio.Io _ as ex ->
6189 let bt = Printexc.get_raw_backtrace () in
6190 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6191 in
6192 if Requests.Response.ok response then
6193 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
6194 else
6195 let body = Requests.Response.text response in
6196 let parsed_body =
6197 match Jsont_bytesrw.decode_string Jsont.json body with
6198 | Ok json -> Some (Openapi.Runtime.Json json)
6199 | Error _ -> Some (Openapi.Runtime.Raw body)
6200 in
6201 raise (Openapi.Runtime.Api_error {
6202 operation = op_name;
6203 method_ = "GET";
6204 url;
6205 status = Requests.Response.status_code response;
6206 body;
6207 parsed_body;
6208 })
6209end
6210
6211module Purchase = struct
6212 module Types = struct
6213 module Update = struct
6214 type t = {
6215 hide_buy_button_until : string option;
6216 show_support_badge : bool option;
6217 }
6218 end
6219
6220 module Response = struct
6221 type t = {
6222 hide_buy_button_until : string;
6223 show_support_badge : bool;
6224 }
6225 end
6226 end
6227
6228 module Update = struct
6229 include Types.Update
6230
6231 let v ?hide_buy_button_until ?show_support_badge () = { hide_buy_button_until; show_support_badge }
6232
6233 let hide_buy_button_until t = t.hide_buy_button_until
6234 let show_support_badge t = t.show_support_badge
6235
6236 let jsont : t Jsont.t =
6237 Jsont.Object.map ~kind:"PurchaseUpdate"
6238 (fun hide_buy_button_until show_support_badge -> { hide_buy_button_until; show_support_badge })
6239 |> Jsont.Object.opt_mem "hideBuyButtonUntil" Jsont.string ~enc:(fun r -> r.hide_buy_button_until)
6240 |> Jsont.Object.opt_mem "showSupportBadge" Jsont.bool ~enc:(fun r -> r.show_support_badge)
6241 |> Jsont.Object.skip_unknown
6242 |> Jsont.Object.finish
6243 end
6244
6245 module Response = struct
6246 include Types.Response
6247
6248 let v ~hide_buy_button_until ~show_support_badge () = { hide_buy_button_until; show_support_badge }
6249
6250 let hide_buy_button_until t = t.hide_buy_button_until
6251 let show_support_badge t = t.show_support_badge
6252
6253 let jsont : t Jsont.t =
6254 Jsont.Object.map ~kind:"PurchaseResponse"
6255 (fun hide_buy_button_until show_support_badge -> { hide_buy_button_until; show_support_badge })
6256 |> Jsont.Object.mem "hideBuyButtonUntil" Jsont.string ~enc:(fun r -> r.hide_buy_button_until)
6257 |> Jsont.Object.mem "showSupportBadge" Jsont.bool ~enc:(fun r -> r.show_support_badge)
6258 |> Jsont.Object.skip_unknown
6259 |> Jsont.Object.finish
6260 end
6261end
6262
6263module PluginContext = struct
6264 module Types = struct
6265 module Type = struct
6266 type t = [
6267 | `Asset
6268 | `Album
6269 | `Person
6270 ]
6271 end
6272 end
6273
6274 module Type = struct
6275 include Types.Type
6276
6277 let jsont : t Jsont.t =
6278 Jsont.map Jsont.string ~kind:"PluginContextType"
6279 ~dec:(function
6280 | "asset" -> `Asset
6281 | "album" -> `Album
6282 | "person" -> `Person
6283 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
6284 ~enc:(function
6285 | `Asset -> "asset"
6286 | `Album -> "album"
6287 | `Person -> "person")
6288 end
6289end
6290
6291module PluginTrigger = struct
6292 module Types = struct
6293 module Type = struct
6294 type t = [
6295 | `Asset_create
6296 | `Person_recognized
6297 ]
6298 end
6299
6300 module ResponseDto = struct
6301 type t = {
6302 context_type : PluginContext.Type.t;
6303 type_ : Type.t;
6304 }
6305 end
6306 end
6307
6308 module Type = struct
6309 include Types.Type
6310
6311 let jsont : t Jsont.t =
6312 Jsont.map Jsont.string ~kind:"PluginTriggerType"
6313 ~dec:(function
6314 | "AssetCreate" -> `Asset_create
6315 | "PersonRecognized" -> `Person_recognized
6316 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
6317 ~enc:(function
6318 | `Asset_create -> "AssetCreate"
6319 | `Person_recognized -> "PersonRecognized")
6320 end
6321
6322 module ResponseDto = struct
6323 include Types.ResponseDto
6324
6325 let v ~context_type ~type_ () = { context_type; type_ }
6326
6327 let context_type t = t.context_type
6328 let type_ t = t.type_
6329
6330 let jsont : t Jsont.t =
6331 Jsont.Object.map ~kind:"PluginTriggerResponseDto"
6332 (fun context_type type_ -> { context_type; type_ })
6333 |> Jsont.Object.mem "contextType" PluginContext.Type.jsont ~enc:(fun r -> r.context_type)
6334 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
6335 |> Jsont.Object.skip_unknown
6336 |> Jsont.Object.finish
6337 end
6338
6339 (** List all plugin triggers
6340
6341 Retrieve a list of all available plugin triggers. *)
6342 let get_plugin_triggers client () =
6343 let op_name = "get_plugin_triggers" in
6344 let url_path = "/plugins/triggers" in
6345 let query = "" in
6346 let url = client.base_url ^ url_path ^ query in
6347 let response =
6348 try Requests.get client.session url
6349 with Eio.Io _ as ex ->
6350 let bt = Printexc.get_raw_backtrace () in
6351 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6352 in
6353 if Requests.Response.ok response then
6354 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6355 else
6356 let body = Requests.Response.text response in
6357 let parsed_body =
6358 match Jsont_bytesrw.decode_string Jsont.json body with
6359 | Ok json -> Some (Openapi.Runtime.Json json)
6360 | Error _ -> Some (Openapi.Runtime.Raw body)
6361 in
6362 raise (Openapi.Runtime.Api_error {
6363 operation = op_name;
6364 method_ = "GET";
6365 url;
6366 status = Requests.Response.status_code response;
6367 body;
6368 parsed_body;
6369 })
6370end
6371
6372module Workflow = struct
6373 module Types = struct
6374 module UpdateDto = struct
6375 type t = {
6376 actions : WorkflowActionItem.Dto.t list option;
6377 description : string option;
6378 enabled : bool option;
6379 filters : WorkflowFilterItem.Dto.t list option;
6380 name : string option;
6381 trigger_type : PluginTrigger.Type.t option;
6382 }
6383 end
6384
6385 module ResponseDto = struct
6386 type t = {
6387 actions : WorkflowAction.ResponseDto.t list;
6388 created_at : string;
6389 description : string;
6390 enabled : bool;
6391 filters : WorkflowFilter.ResponseDto.t list;
6392 id : string;
6393 name : string option;
6394 owner_id : string;
6395 trigger_type : PluginTrigger.Type.t;
6396 }
6397 end
6398
6399 module CreateDto = struct
6400 type t = {
6401 actions : WorkflowActionItem.Dto.t list;
6402 description : string option;
6403 enabled : bool option;
6404 filters : WorkflowFilterItem.Dto.t list;
6405 name : string;
6406 trigger_type : PluginTrigger.Type.t;
6407 }
6408 end
6409 end
6410
6411 module UpdateDto = struct
6412 include Types.UpdateDto
6413
6414 let v ?actions ?description ?enabled ?filters ?name ?trigger_type () = { actions; description; enabled; filters; name; trigger_type }
6415
6416 let actions t = t.actions
6417 let description t = t.description
6418 let enabled t = t.enabled
6419 let filters t = t.filters
6420 let name t = t.name
6421 let trigger_type t = t.trigger_type
6422
6423 let jsont : t Jsont.t =
6424 Jsont.Object.map ~kind:"WorkflowUpdateDto"
6425 (fun actions description enabled filters name trigger_type -> { actions; description; enabled; filters; name; trigger_type })
6426 |> Jsont.Object.opt_mem "actions" (Jsont.list WorkflowActionItem.Dto.jsont) ~enc:(fun r -> r.actions)
6427 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
6428 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
6429 |> Jsont.Object.opt_mem "filters" (Jsont.list WorkflowFilterItem.Dto.jsont) ~enc:(fun r -> r.filters)
6430 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
6431 |> Jsont.Object.opt_mem "triggerType" PluginTrigger.Type.jsont ~enc:(fun r -> r.trigger_type)
6432 |> Jsont.Object.skip_unknown
6433 |> Jsont.Object.finish
6434 end
6435
6436 module ResponseDto = struct
6437 include Types.ResponseDto
6438
6439 let v ~actions ~created_at ~description ~enabled ~filters ~id ~owner_id ~trigger_type ?name () = { actions; created_at; description; enabled; filters; id; name; owner_id; trigger_type }
6440
6441 let actions t = t.actions
6442 let created_at t = t.created_at
6443 let description t = t.description
6444 let enabled t = t.enabled
6445 let filters t = t.filters
6446 let id t = t.id
6447 let name t = t.name
6448 let owner_id t = t.owner_id
6449 let trigger_type t = t.trigger_type
6450
6451 let jsont : t Jsont.t =
6452 Jsont.Object.map ~kind:"WorkflowResponseDto"
6453 (fun actions created_at description enabled filters id name owner_id trigger_type -> { actions; created_at; description; enabled; filters; id; name; owner_id; trigger_type })
6454 |> Jsont.Object.mem "actions" (Jsont.list WorkflowAction.ResponseDto.jsont) ~enc:(fun r -> r.actions)
6455 |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
6456 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
6457 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
6458 |> Jsont.Object.mem "filters" (Jsont.list WorkflowFilter.ResponseDto.jsont) ~enc:(fun r -> r.filters)
6459 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
6460 |> Jsont.Object.mem "name" Openapi.Runtime.nullable_string
6461 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.name)
6462 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
6463 |> Jsont.Object.mem "triggerType" PluginTrigger.Type.jsont ~enc:(fun r -> r.trigger_type)
6464 |> Jsont.Object.skip_unknown
6465 |> Jsont.Object.finish
6466 end
6467
6468 module CreateDto = struct
6469 include Types.CreateDto
6470
6471 let v ~actions ~filters ~name ~trigger_type ?description ?enabled () = { actions; description; enabled; filters; name; trigger_type }
6472
6473 let actions t = t.actions
6474 let description t = t.description
6475 let enabled t = t.enabled
6476 let filters t = t.filters
6477 let name t = t.name
6478 let trigger_type t = t.trigger_type
6479
6480 let jsont : t Jsont.t =
6481 Jsont.Object.map ~kind:"WorkflowCreateDto"
6482 (fun actions description enabled filters name trigger_type -> { actions; description; enabled; filters; name; trigger_type })
6483 |> Jsont.Object.mem "actions" (Jsont.list WorkflowActionItem.Dto.jsont) ~enc:(fun r -> r.actions)
6484 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
6485 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
6486 |> Jsont.Object.mem "filters" (Jsont.list WorkflowFilterItem.Dto.jsont) ~enc:(fun r -> r.filters)
6487 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
6488 |> Jsont.Object.mem "triggerType" PluginTrigger.Type.jsont ~enc:(fun r -> r.trigger_type)
6489 |> Jsont.Object.skip_unknown
6490 |> Jsont.Object.finish
6491 end
6492
6493 (** List all workflows
6494
6495 Retrieve a list of workflows available to the authenticated user. *)
6496 let get_workflows client () =
6497 let op_name = "get_workflows" in
6498 let url_path = "/workflows" in
6499 let query = "" in
6500 let url = client.base_url ^ url_path ^ query in
6501 let response =
6502 try Requests.get client.session url
6503 with Eio.Io _ as ex ->
6504 let bt = Printexc.get_raw_backtrace () in
6505 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6506 in
6507 if Requests.Response.ok response then
6508 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6509 else
6510 let body = Requests.Response.text response in
6511 let parsed_body =
6512 match Jsont_bytesrw.decode_string Jsont.json body with
6513 | Ok json -> Some (Openapi.Runtime.Json json)
6514 | Error _ -> Some (Openapi.Runtime.Raw body)
6515 in
6516 raise (Openapi.Runtime.Api_error {
6517 operation = op_name;
6518 method_ = "GET";
6519 url;
6520 status = Requests.Response.status_code response;
6521 body;
6522 parsed_body;
6523 })
6524
6525 (** Create a workflow
6526
6527 Create a new workflow, the workflow can also be created with empty filters and actions. *)
6528 let create_workflow ~body client () =
6529 let op_name = "create_workflow" in
6530 let url_path = "/workflows" in
6531 let query = "" in
6532 let url = client.base_url ^ url_path ^ query in
6533 let response =
6534 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
6535 with Eio.Io _ as ex ->
6536 let bt = Printexc.get_raw_backtrace () in
6537 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
6538 in
6539 if Requests.Response.ok response then
6540 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6541 else
6542 let body = Requests.Response.text response in
6543 let parsed_body =
6544 match Jsont_bytesrw.decode_string Jsont.json body with
6545 | Ok json -> Some (Openapi.Runtime.Json json)
6546 | Error _ -> Some (Openapi.Runtime.Raw body)
6547 in
6548 raise (Openapi.Runtime.Api_error {
6549 operation = op_name;
6550 method_ = "POST";
6551 url;
6552 status = Requests.Response.status_code response;
6553 body;
6554 parsed_body;
6555 })
6556
6557 (** Retrieve a workflow
6558
6559 Retrieve information about a specific workflow by its ID. *)
6560 let get_workflow ~id client () =
6561 let op_name = "get_workflow" in
6562 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/workflows/{id}" in
6563 let query = "" in
6564 let url = client.base_url ^ url_path ^ query in
6565 let response =
6566 try Requests.get client.session url
6567 with Eio.Io _ as ex ->
6568 let bt = Printexc.get_raw_backtrace () in
6569 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6570 in
6571 if Requests.Response.ok response then
6572 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6573 else
6574 let body = Requests.Response.text response in
6575 let parsed_body =
6576 match Jsont_bytesrw.decode_string Jsont.json body with
6577 | Ok json -> Some (Openapi.Runtime.Json json)
6578 | Error _ -> Some (Openapi.Runtime.Raw body)
6579 in
6580 raise (Openapi.Runtime.Api_error {
6581 operation = op_name;
6582 method_ = "GET";
6583 url;
6584 status = Requests.Response.status_code response;
6585 body;
6586 parsed_body;
6587 })
6588
6589 (** Update a workflow
6590
6591 Update the information of a specific workflow by its ID. This endpoint can be used to update the workflow name, description, trigger type, filters and actions order, etc. *)
6592 let update_workflow ~id ~body client () =
6593 let op_name = "update_workflow" in
6594 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/workflows/{id}" in
6595 let query = "" in
6596 let url = client.base_url ^ url_path ^ query in
6597 let response =
6598 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
6599 with Eio.Io _ as ex ->
6600 let bt = Printexc.get_raw_backtrace () in
6601 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
6602 in
6603 if Requests.Response.ok response then
6604 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6605 else
6606 let body = Requests.Response.text response in
6607 let parsed_body =
6608 match Jsont_bytesrw.decode_string Jsont.json body with
6609 | Ok json -> Some (Openapi.Runtime.Json json)
6610 | Error _ -> Some (Openapi.Runtime.Raw body)
6611 in
6612 raise (Openapi.Runtime.Api_error {
6613 operation = op_name;
6614 method_ = "PUT";
6615 url;
6616 status = Requests.Response.status_code response;
6617 body;
6618 parsed_body;
6619 })
6620end
6621
6622module PluginFilter = struct
6623 module Types = struct
6624 module ResponseDto = struct
6625 type t = {
6626 description : string;
6627 id : string;
6628 method_name : string;
6629 plugin_id : string;
6630 schema : Jsont.json option;
6631 supported_contexts : PluginContext.Type.t list;
6632 title : string;
6633 }
6634 end
6635 end
6636
6637 module ResponseDto = struct
6638 include Types.ResponseDto
6639
6640 let v ~description ~id ~method_name ~plugin_id ~supported_contexts ~title ?schema () = { description; id; method_name; plugin_id; schema; supported_contexts; title }
6641
6642 let description t = t.description
6643 let id t = t.id
6644 let method_name t = t.method_name
6645 let plugin_id t = t.plugin_id
6646 let schema t = t.schema
6647 let supported_contexts t = t.supported_contexts
6648 let title t = t.title
6649
6650 let jsont : t Jsont.t =
6651 Jsont.Object.map ~kind:"PluginFilterResponseDto"
6652 (fun description id method_name plugin_id schema supported_contexts title -> { description; id; method_name; plugin_id; schema; supported_contexts; title })
6653 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
6654 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
6655 |> Jsont.Object.mem "methodName" Jsont.string ~enc:(fun r -> r.method_name)
6656 |> Jsont.Object.mem "pluginId" Jsont.string ~enc:(fun r -> r.plugin_id)
6657 |> Jsont.Object.mem "schema" (Openapi.Runtime.nullable_any Jsont.json)
6658 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.schema)
6659 |> Jsont.Object.mem "supportedContexts" (Jsont.list PluginContext.Type.jsont) ~enc:(fun r -> r.supported_contexts)
6660 |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
6661 |> Jsont.Object.skip_unknown
6662 |> Jsont.Object.finish
6663 end
6664end
6665
6666module PluginAction = struct
6667 module Types = struct
6668 module ResponseDto = struct
6669 type t = {
6670 description : string;
6671 id : string;
6672 method_name : string;
6673 plugin_id : string;
6674 schema : Jsont.json option;
6675 supported_contexts : PluginContext.Type.t list;
6676 title : string;
6677 }
6678 end
6679 end
6680
6681 module ResponseDto = struct
6682 include Types.ResponseDto
6683
6684 let v ~description ~id ~method_name ~plugin_id ~supported_contexts ~title ?schema () = { description; id; method_name; plugin_id; schema; supported_contexts; title }
6685
6686 let description t = t.description
6687 let id t = t.id
6688 let method_name t = t.method_name
6689 let plugin_id t = t.plugin_id
6690 let schema t = t.schema
6691 let supported_contexts t = t.supported_contexts
6692 let title t = t.title
6693
6694 let jsont : t Jsont.t =
6695 Jsont.Object.map ~kind:"PluginActionResponseDto"
6696 (fun description id method_name plugin_id schema supported_contexts title -> { description; id; method_name; plugin_id; schema; supported_contexts; title })
6697 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
6698 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
6699 |> Jsont.Object.mem "methodName" Jsont.string ~enc:(fun r -> r.method_name)
6700 |> Jsont.Object.mem "pluginId" Jsont.string ~enc:(fun r -> r.plugin_id)
6701 |> Jsont.Object.mem "schema" (Openapi.Runtime.nullable_any Jsont.json)
6702 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.schema)
6703 |> Jsont.Object.mem "supportedContexts" (Jsont.list PluginContext.Type.jsont) ~enc:(fun r -> r.supported_contexts)
6704 |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
6705 |> Jsont.Object.skip_unknown
6706 |> Jsont.Object.finish
6707 end
6708end
6709
6710module Plugin = struct
6711 module Types = struct
6712 module ResponseDto = struct
6713 type t = {
6714 actions : PluginAction.ResponseDto.t list;
6715 author : string;
6716 created_at : string;
6717 description : string;
6718 filters : PluginFilter.ResponseDto.t list;
6719 id : string;
6720 name : string;
6721 title : string;
6722 updated_at : string;
6723 version : string;
6724 }
6725 end
6726 end
6727
6728 module ResponseDto = struct
6729 include Types.ResponseDto
6730
6731 let v ~actions ~author ~created_at ~description ~filters ~id ~name ~title ~updated_at ~version () = { actions; author; created_at; description; filters; id; name; title; updated_at; version }
6732
6733 let actions t = t.actions
6734 let author t = t.author
6735 let created_at t = t.created_at
6736 let description t = t.description
6737 let filters t = t.filters
6738 let id t = t.id
6739 let name t = t.name
6740 let title t = t.title
6741 let updated_at t = t.updated_at
6742 let version t = t.version
6743
6744 let jsont : t Jsont.t =
6745 Jsont.Object.map ~kind:"PluginResponseDto"
6746 (fun actions author created_at description filters id name title updated_at version -> { actions; author; created_at; description; filters; id; name; title; updated_at; version })
6747 |> Jsont.Object.mem "actions" (Jsont.list PluginAction.ResponseDto.jsont) ~enc:(fun r -> r.actions)
6748 |> Jsont.Object.mem "author" Jsont.string ~enc:(fun r -> r.author)
6749 |> Jsont.Object.mem "createdAt" Jsont.string ~enc:(fun r -> r.created_at)
6750 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
6751 |> Jsont.Object.mem "filters" (Jsont.list PluginFilter.ResponseDto.jsont) ~enc:(fun r -> r.filters)
6752 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
6753 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
6754 |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
6755 |> Jsont.Object.mem "updatedAt" Jsont.string ~enc:(fun r -> r.updated_at)
6756 |> Jsont.Object.mem "version" Jsont.string ~enc:(fun r -> r.version)
6757 |> Jsont.Object.skip_unknown
6758 |> Jsont.Object.finish
6759 end
6760
6761 (** List all plugins
6762
6763 Retrieve a list of plugins available to the authenticated user. *)
6764 let get_plugins client () =
6765 let op_name = "get_plugins" in
6766 let url_path = "/plugins" in
6767 let query = "" in
6768 let url = client.base_url ^ url_path ^ query in
6769 let response =
6770 try Requests.get client.session url
6771 with Eio.Io _ as ex ->
6772 let bt = Printexc.get_raw_backtrace () in
6773 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6774 in
6775 if Requests.Response.ok response then
6776 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6777 else
6778 let body = Requests.Response.text response in
6779 let parsed_body =
6780 match Jsont_bytesrw.decode_string Jsont.json body with
6781 | Ok json -> Some (Openapi.Runtime.Json json)
6782 | Error _ -> Some (Openapi.Runtime.Raw body)
6783 in
6784 raise (Openapi.Runtime.Api_error {
6785 operation = op_name;
6786 method_ = "GET";
6787 url;
6788 status = Requests.Response.status_code response;
6789 body;
6790 parsed_body;
6791 })
6792
6793 (** Retrieve a plugin
6794
6795 Retrieve information about a specific plugin by its ID. *)
6796 let get_plugin ~id client () =
6797 let op_name = "get_plugin" in
6798 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/plugins/{id}" in
6799 let query = "" in
6800 let url = client.base_url ^ url_path ^ query in
6801 let response =
6802 try Requests.get client.session url
6803 with Eio.Io _ as ex ->
6804 let bt = Printexc.get_raw_backtrace () in
6805 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6806 in
6807 if Requests.Response.ok response then
6808 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6809 else
6810 let body = Requests.Response.text response in
6811 let parsed_body =
6812 match Jsont_bytesrw.decode_string Jsont.json body with
6813 | Ok json -> Some (Openapi.Runtime.Json json)
6814 | Error _ -> Some (Openapi.Runtime.Raw body)
6815 in
6816 raise (Openapi.Runtime.Api_error {
6817 operation = op_name;
6818 method_ = "GET";
6819 url;
6820 status = Requests.Response.status_code response;
6821 body;
6822 parsed_body;
6823 })
6824end
6825
6826module Places = struct
6827 module Types = struct
6828 module ResponseDto = struct
6829 type t = {
6830 admin1name : string option;
6831 admin2name : string option;
6832 latitude : float;
6833 longitude : float;
6834 name : string;
6835 }
6836 end
6837 end
6838
6839 module ResponseDto = struct
6840 include Types.ResponseDto
6841
6842 let v ~latitude ~longitude ~name ?admin1name ?admin2name () = { admin1name; admin2name; latitude; longitude; name }
6843
6844 let admin1name t = t.admin1name
6845 let admin2name t = t.admin2name
6846 let latitude t = t.latitude
6847 let longitude t = t.longitude
6848 let name t = t.name
6849
6850 let jsont : t Jsont.t =
6851 Jsont.Object.map ~kind:"PlacesResponseDto"
6852 (fun admin1name admin2name latitude longitude name -> { admin1name; admin2name; latitude; longitude; name })
6853 |> Jsont.Object.opt_mem "admin1name" Jsont.string ~enc:(fun r -> r.admin1name)
6854 |> Jsont.Object.opt_mem "admin2name" Jsont.string ~enc:(fun r -> r.admin2name)
6855 |> Jsont.Object.mem "latitude" Jsont.number ~enc:(fun r -> r.latitude)
6856 |> Jsont.Object.mem "longitude" Jsont.number ~enc:(fun r -> r.longitude)
6857 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
6858 |> Jsont.Object.skip_unknown
6859 |> Jsont.Object.finish
6860 end
6861
6862 (** Search places
6863
6864 Search for places by name. *)
6865 let search_places ~name client () =
6866 let op_name = "search_places" in
6867 let url_path = "/search/places" in
6868 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"name" ~value:name]) in
6869 let url = client.base_url ^ url_path ^ query in
6870 let response =
6871 try Requests.get client.session url
6872 with Eio.Io _ as ex ->
6873 let bt = Printexc.get_raw_backtrace () in
6874 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
6875 in
6876 if Requests.Response.ok response then
6877 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
6878 else
6879 let body = Requests.Response.text response in
6880 let parsed_body =
6881 match Jsont_bytesrw.decode_string Jsont.json body with
6882 | Ok json -> Some (Openapi.Runtime.Json json)
6883 | Error _ -> Some (Openapi.Runtime.Raw body)
6884 in
6885 raise (Openapi.Runtime.Api_error {
6886 operation = op_name;
6887 method_ = "GET";
6888 url;
6889 status = Requests.Response.status_code response;
6890 body;
6891 parsed_body;
6892 })
6893end
6894
6895module PinCodeSetup = struct
6896 module Types = struct
6897 module Dto = struct
6898 type t = {
6899 pin_code : string;
6900 }
6901 end
6902 end
6903
6904 module Dto = struct
6905 include Types.Dto
6906
6907 let v ~pin_code () = { pin_code }
6908
6909 let pin_code t = t.pin_code
6910
6911 let jsont : t Jsont.t =
6912 Jsont.Object.map ~kind:"PinCodeSetupDto"
6913 (fun pin_code -> { pin_code })
6914 |> Jsont.Object.mem "pinCode" Jsont.string ~enc:(fun r -> r.pin_code)
6915 |> Jsont.Object.skip_unknown
6916 |> Jsont.Object.finish
6917 end
6918end
6919
6920module PinCodeReset = struct
6921 module Types = struct
6922 module Dto = struct
6923 type t = {
6924 password : string option;
6925 pin_code : string option;
6926 }
6927 end
6928 end
6929
6930 module Dto = struct
6931 include Types.Dto
6932
6933 let v ?password ?pin_code () = { password; pin_code }
6934
6935 let password t = t.password
6936 let pin_code t = t.pin_code
6937
6938 let jsont : t Jsont.t =
6939 Jsont.Object.map ~kind:"PinCodeResetDto"
6940 (fun password pin_code -> { password; pin_code })
6941 |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
6942 |> Jsont.Object.opt_mem "pinCode" Jsont.string ~enc:(fun r -> r.pin_code)
6943 |> Jsont.Object.skip_unknown
6944 |> Jsont.Object.finish
6945 end
6946end
6947
6948module PinCodeChange = struct
6949 module Types = struct
6950 module Dto = struct
6951 type t = {
6952 new_pin_code : string;
6953 password : string option;
6954 pin_code : string option;
6955 }
6956 end
6957 end
6958
6959 module Dto = struct
6960 include Types.Dto
6961
6962 let v ~new_pin_code ?password ?pin_code () = { new_pin_code; password; pin_code }
6963
6964 let new_pin_code t = t.new_pin_code
6965 let password t = t.password
6966 let pin_code t = t.pin_code
6967
6968 let jsont : t Jsont.t =
6969 Jsont.Object.map ~kind:"PinCodeChangeDto"
6970 (fun new_pin_code password pin_code -> { new_pin_code; password; pin_code })
6971 |> Jsont.Object.mem "newPinCode" Jsont.string ~enc:(fun r -> r.new_pin_code)
6972 |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
6973 |> Jsont.Object.opt_mem "pinCode" Jsont.string ~enc:(fun r -> r.pin_code)
6974 |> Jsont.Object.skip_unknown
6975 |> Jsont.Object.finish
6976 end
6977end
6978
6979module PersonStatistics = struct
6980 module Types = struct
6981 module ResponseDto = struct
6982 type t = {
6983 assets : int;
6984 }
6985 end
6986 end
6987
6988 module ResponseDto = struct
6989 include Types.ResponseDto
6990
6991 let v ~assets () = { assets }
6992
6993 let assets t = t.assets
6994
6995 let jsont : t Jsont.t =
6996 Jsont.Object.map ~kind:"PersonStatisticsResponseDto"
6997 (fun assets -> { assets })
6998 |> Jsont.Object.mem "assets" Jsont.int ~enc:(fun r -> r.assets)
6999 |> Jsont.Object.skip_unknown
7000 |> Jsont.Object.finish
7001 end
7002
7003 (** Get person statistics
7004
7005 Retrieve statistics about a specific person. *)
7006 let get_person_statistics ~id client () =
7007 let op_name = "get_person_statistics" in
7008 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}/statistics" in
7009 let query = "" in
7010 let url = client.base_url ^ url_path ^ query in
7011 let response =
7012 try Requests.get client.session url
7013 with Eio.Io _ as ex ->
7014 let bt = Printexc.get_raw_backtrace () in
7015 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
7016 in
7017 if Requests.Response.ok response then
7018 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7019 else
7020 let body = Requests.Response.text response in
7021 let parsed_body =
7022 match Jsont_bytesrw.decode_string Jsont.json body with
7023 | Ok json -> Some (Openapi.Runtime.Json json)
7024 | Error _ -> Some (Openapi.Runtime.Raw body)
7025 in
7026 raise (Openapi.Runtime.Api_error {
7027 operation = op_name;
7028 method_ = "GET";
7029 url;
7030 status = Requests.Response.status_code response;
7031 body;
7032 parsed_body;
7033 })
7034end
7035
7036module Permission = struct
7037 module Types = struct
7038 module T = struct
7039 type t = [
7040 | `All
7041 | `Activity_create
7042 | `Activity_read
7043 | `Activity_update
7044 | `Activity_delete
7045 | `Activity_statistics
7046 | `Api_key_create
7047 | `Api_key_read
7048 | `Api_key_update
7049 | `Api_key_delete
7050 | `Asset_read
7051 | `Asset_update
7052 | `Asset_delete
7053 | `Asset_statistics
7054 | `Asset_share
7055 | `Asset_view
7056 | `Asset_download
7057 | `Asset_upload
7058 | `Asset_replace
7059 | `Asset_copy
7060 | `Asset_derive
7061 | `Asset_edit_get
7062 | `Asset_edit_create
7063 | `Asset_edit_delete
7064 | `Album_create
7065 | `Album_read
7066 | `Album_update
7067 | `Album_delete
7068 | `Album_statistics
7069 | `Album_share
7070 | `Album_download
7071 | `Album_asset_create
7072 | `Album_asset_delete
7073 | `Album_user_create
7074 | `Album_user_update
7075 | `Album_user_delete
7076 | `Auth_change_password
7077 | `Auth_device_delete
7078 | `Archive_read
7079 | `Backup_list
7080 | `Backup_download
7081 | `Backup_upload
7082 | `Backup_delete
7083 | `Duplicate_read
7084 | `Duplicate_delete
7085 | `Face_create
7086 | `Face_read
7087 | `Face_update
7088 | `Face_delete
7089 | `Folder_read
7090 | `Job_create
7091 | `Job_read
7092 | `Library_create
7093 | `Library_read
7094 | `Library_update
7095 | `Library_delete
7096 | `Library_statistics
7097 | `Timeline_read
7098 | `Timeline_download
7099 | `Maintenance
7100 | `Map_read
7101 | `Map_search
7102 | `Memory_create
7103 | `Memory_read
7104 | `Memory_update
7105 | `Memory_delete
7106 | `Memory_statistics
7107 | `Memory_asset_create
7108 | `Memory_asset_delete
7109 | `Notification_create
7110 | `Notification_read
7111 | `Notification_update
7112 | `Notification_delete
7113 | `Partner_create
7114 | `Partner_read
7115 | `Partner_update
7116 | `Partner_delete
7117 | `Person_create
7118 | `Person_read
7119 | `Person_update
7120 | `Person_delete
7121 | `Person_statistics
7122 | `Person_merge
7123 | `Person_reassign
7124 | `Pin_code_create
7125 | `Pin_code_update
7126 | `Pin_code_delete
7127 | `Plugin_create
7128 | `Plugin_read
7129 | `Plugin_update
7130 | `Plugin_delete
7131 | `Server_about
7132 | `Server_apk_links
7133 | `Server_storage
7134 | `Server_statistics
7135 | `Server_version_check
7136 | `Server_license_read
7137 | `Server_license_update
7138 | `Server_license_delete
7139 | `Session_create
7140 | `Session_read
7141 | `Session_update
7142 | `Session_delete
7143 | `Session_lock
7144 | `Shared_link_create
7145 | `Shared_link_read
7146 | `Shared_link_update
7147 | `Shared_link_delete
7148 | `Stack_create
7149 | `Stack_read
7150 | `Stack_update
7151 | `Stack_delete
7152 | `Sync_stream
7153 | `Sync_checkpoint_read
7154 | `Sync_checkpoint_update
7155 | `Sync_checkpoint_delete
7156 | `System_config_read
7157 | `System_config_update
7158 | `System_metadata_read
7159 | `System_metadata_update
7160 | `Tag_create
7161 | `Tag_read
7162 | `Tag_update
7163 | `Tag_delete
7164 | `Tag_asset
7165 | `User_read
7166 | `User_update
7167 | `User_license_create
7168 | `User_license_read
7169 | `User_license_update
7170 | `User_license_delete
7171 | `User_onboarding_read
7172 | `User_onboarding_update
7173 | `User_onboarding_delete
7174 | `User_preference_read
7175 | `User_preference_update
7176 | `User_profile_image_create
7177 | `User_profile_image_read
7178 | `User_profile_image_update
7179 | `User_profile_image_delete
7180 | `Queue_read
7181 | `Queue_update
7182 | `Queue_job_create
7183 | `Queue_job_read
7184 | `Queue_job_update
7185 | `Queue_job_delete
7186 | `Workflow_create
7187 | `Workflow_read
7188 | `Workflow_update
7189 | `Workflow_delete
7190 | `Admin_user_create
7191 | `Admin_user_read
7192 | `Admin_user_update
7193 | `Admin_user_delete
7194 | `Admin_session_read
7195 | `Admin_auth_unlink_all
7196 ]
7197 end
7198 end
7199
7200 module T = struct
7201 include Types.T
7202
7203 let jsont : t Jsont.t =
7204 Jsont.map Jsont.string ~kind:"Permission"
7205 ~dec:(function
7206 | "all" -> `All
7207 | "activity.create" -> `Activity_create
7208 | "activity.read" -> `Activity_read
7209 | "activity.update" -> `Activity_update
7210 | "activity.delete" -> `Activity_delete
7211 | "activity.statistics" -> `Activity_statistics
7212 | "apiKey.create" -> `Api_key_create
7213 | "apiKey.read" -> `Api_key_read
7214 | "apiKey.update" -> `Api_key_update
7215 | "apiKey.delete" -> `Api_key_delete
7216 | "asset.read" -> `Asset_read
7217 | "asset.update" -> `Asset_update
7218 | "asset.delete" -> `Asset_delete
7219 | "asset.statistics" -> `Asset_statistics
7220 | "asset.share" -> `Asset_share
7221 | "asset.view" -> `Asset_view
7222 | "asset.download" -> `Asset_download
7223 | "asset.upload" -> `Asset_upload
7224 | "asset.replace" -> `Asset_replace
7225 | "asset.copy" -> `Asset_copy
7226 | "asset.derive" -> `Asset_derive
7227 | "asset.edit.get" -> `Asset_edit_get
7228 | "asset.edit.create" -> `Asset_edit_create
7229 | "asset.edit.delete" -> `Asset_edit_delete
7230 | "album.create" -> `Album_create
7231 | "album.read" -> `Album_read
7232 | "album.update" -> `Album_update
7233 | "album.delete" -> `Album_delete
7234 | "album.statistics" -> `Album_statistics
7235 | "album.share" -> `Album_share
7236 | "album.download" -> `Album_download
7237 | "albumAsset.create" -> `Album_asset_create
7238 | "albumAsset.delete" -> `Album_asset_delete
7239 | "albumUser.create" -> `Album_user_create
7240 | "albumUser.update" -> `Album_user_update
7241 | "albumUser.delete" -> `Album_user_delete
7242 | "auth.changePassword" -> `Auth_change_password
7243 | "authDevice.delete" -> `Auth_device_delete
7244 | "archive.read" -> `Archive_read
7245 | "backup.list" -> `Backup_list
7246 | "backup.download" -> `Backup_download
7247 | "backup.upload" -> `Backup_upload
7248 | "backup.delete" -> `Backup_delete
7249 | "duplicate.read" -> `Duplicate_read
7250 | "duplicate.delete" -> `Duplicate_delete
7251 | "face.create" -> `Face_create
7252 | "face.read" -> `Face_read
7253 | "face.update" -> `Face_update
7254 | "face.delete" -> `Face_delete
7255 | "folder.read" -> `Folder_read
7256 | "job.create" -> `Job_create
7257 | "job.read" -> `Job_read
7258 | "library.create" -> `Library_create
7259 | "library.read" -> `Library_read
7260 | "library.update" -> `Library_update
7261 | "library.delete" -> `Library_delete
7262 | "library.statistics" -> `Library_statistics
7263 | "timeline.read" -> `Timeline_read
7264 | "timeline.download" -> `Timeline_download
7265 | "maintenance" -> `Maintenance
7266 | "map.read" -> `Map_read
7267 | "map.search" -> `Map_search
7268 | "memory.create" -> `Memory_create
7269 | "memory.read" -> `Memory_read
7270 | "memory.update" -> `Memory_update
7271 | "memory.delete" -> `Memory_delete
7272 | "memory.statistics" -> `Memory_statistics
7273 | "memoryAsset.create" -> `Memory_asset_create
7274 | "memoryAsset.delete" -> `Memory_asset_delete
7275 | "notification.create" -> `Notification_create
7276 | "notification.read" -> `Notification_read
7277 | "notification.update" -> `Notification_update
7278 | "notification.delete" -> `Notification_delete
7279 | "partner.create" -> `Partner_create
7280 | "partner.read" -> `Partner_read
7281 | "partner.update" -> `Partner_update
7282 | "partner.delete" -> `Partner_delete
7283 | "person.create" -> `Person_create
7284 | "person.read" -> `Person_read
7285 | "person.update" -> `Person_update
7286 | "person.delete" -> `Person_delete
7287 | "person.statistics" -> `Person_statistics
7288 | "person.merge" -> `Person_merge
7289 | "person.reassign" -> `Person_reassign
7290 | "pinCode.create" -> `Pin_code_create
7291 | "pinCode.update" -> `Pin_code_update
7292 | "pinCode.delete" -> `Pin_code_delete
7293 | "plugin.create" -> `Plugin_create
7294 | "plugin.read" -> `Plugin_read
7295 | "plugin.update" -> `Plugin_update
7296 | "plugin.delete" -> `Plugin_delete
7297 | "server.about" -> `Server_about
7298 | "server.apkLinks" -> `Server_apk_links
7299 | "server.storage" -> `Server_storage
7300 | "server.statistics" -> `Server_statistics
7301 | "server.versionCheck" -> `Server_version_check
7302 | "serverLicense.read" -> `Server_license_read
7303 | "serverLicense.update" -> `Server_license_update
7304 | "serverLicense.delete" -> `Server_license_delete
7305 | "session.create" -> `Session_create
7306 | "session.read" -> `Session_read
7307 | "session.update" -> `Session_update
7308 | "session.delete" -> `Session_delete
7309 | "session.lock" -> `Session_lock
7310 | "sharedLink.create" -> `Shared_link_create
7311 | "sharedLink.read" -> `Shared_link_read
7312 | "sharedLink.update" -> `Shared_link_update
7313 | "sharedLink.delete" -> `Shared_link_delete
7314 | "stack.create" -> `Stack_create
7315 | "stack.read" -> `Stack_read
7316 | "stack.update" -> `Stack_update
7317 | "stack.delete" -> `Stack_delete
7318 | "sync.stream" -> `Sync_stream
7319 | "syncCheckpoint.read" -> `Sync_checkpoint_read
7320 | "syncCheckpoint.update" -> `Sync_checkpoint_update
7321 | "syncCheckpoint.delete" -> `Sync_checkpoint_delete
7322 | "systemConfig.read" -> `System_config_read
7323 | "systemConfig.update" -> `System_config_update
7324 | "systemMetadata.read" -> `System_metadata_read
7325 | "systemMetadata.update" -> `System_metadata_update
7326 | "tag.create" -> `Tag_create
7327 | "tag.read" -> `Tag_read
7328 | "tag.update" -> `Tag_update
7329 | "tag.delete" -> `Tag_delete
7330 | "tag.asset" -> `Tag_asset
7331 | "user.read" -> `User_read
7332 | "user.update" -> `User_update
7333 | "userLicense.create" -> `User_license_create
7334 | "userLicense.read" -> `User_license_read
7335 | "userLicense.update" -> `User_license_update
7336 | "userLicense.delete" -> `User_license_delete
7337 | "userOnboarding.read" -> `User_onboarding_read
7338 | "userOnboarding.update" -> `User_onboarding_update
7339 | "userOnboarding.delete" -> `User_onboarding_delete
7340 | "userPreference.read" -> `User_preference_read
7341 | "userPreference.update" -> `User_preference_update
7342 | "userProfileImage.create" -> `User_profile_image_create
7343 | "userProfileImage.read" -> `User_profile_image_read
7344 | "userProfileImage.update" -> `User_profile_image_update
7345 | "userProfileImage.delete" -> `User_profile_image_delete
7346 | "queue.read" -> `Queue_read
7347 | "queue.update" -> `Queue_update
7348 | "queueJob.create" -> `Queue_job_create
7349 | "queueJob.read" -> `Queue_job_read
7350 | "queueJob.update" -> `Queue_job_update
7351 | "queueJob.delete" -> `Queue_job_delete
7352 | "workflow.create" -> `Workflow_create
7353 | "workflow.read" -> `Workflow_read
7354 | "workflow.update" -> `Workflow_update
7355 | "workflow.delete" -> `Workflow_delete
7356 | "adminUser.create" -> `Admin_user_create
7357 | "adminUser.read" -> `Admin_user_read
7358 | "adminUser.update" -> `Admin_user_update
7359 | "adminUser.delete" -> `Admin_user_delete
7360 | "adminSession.read" -> `Admin_session_read
7361 | "adminAuth.unlinkAll" -> `Admin_auth_unlink_all
7362 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
7363 ~enc:(function
7364 | `All -> "all"
7365 | `Activity_create -> "activity.create"
7366 | `Activity_read -> "activity.read"
7367 | `Activity_update -> "activity.update"
7368 | `Activity_delete -> "activity.delete"
7369 | `Activity_statistics -> "activity.statistics"
7370 | `Api_key_create -> "apiKey.create"
7371 | `Api_key_read -> "apiKey.read"
7372 | `Api_key_update -> "apiKey.update"
7373 | `Api_key_delete -> "apiKey.delete"
7374 | `Asset_read -> "asset.read"
7375 | `Asset_update -> "asset.update"
7376 | `Asset_delete -> "asset.delete"
7377 | `Asset_statistics -> "asset.statistics"
7378 | `Asset_share -> "asset.share"
7379 | `Asset_view -> "asset.view"
7380 | `Asset_download -> "asset.download"
7381 | `Asset_upload -> "asset.upload"
7382 | `Asset_replace -> "asset.replace"
7383 | `Asset_copy -> "asset.copy"
7384 | `Asset_derive -> "asset.derive"
7385 | `Asset_edit_get -> "asset.edit.get"
7386 | `Asset_edit_create -> "asset.edit.create"
7387 | `Asset_edit_delete -> "asset.edit.delete"
7388 | `Album_create -> "album.create"
7389 | `Album_read -> "album.read"
7390 | `Album_update -> "album.update"
7391 | `Album_delete -> "album.delete"
7392 | `Album_statistics -> "album.statistics"
7393 | `Album_share -> "album.share"
7394 | `Album_download -> "album.download"
7395 | `Album_asset_create -> "albumAsset.create"
7396 | `Album_asset_delete -> "albumAsset.delete"
7397 | `Album_user_create -> "albumUser.create"
7398 | `Album_user_update -> "albumUser.update"
7399 | `Album_user_delete -> "albumUser.delete"
7400 | `Auth_change_password -> "auth.changePassword"
7401 | `Auth_device_delete -> "authDevice.delete"
7402 | `Archive_read -> "archive.read"
7403 | `Backup_list -> "backup.list"
7404 | `Backup_download -> "backup.download"
7405 | `Backup_upload -> "backup.upload"
7406 | `Backup_delete -> "backup.delete"
7407 | `Duplicate_read -> "duplicate.read"
7408 | `Duplicate_delete -> "duplicate.delete"
7409 | `Face_create -> "face.create"
7410 | `Face_read -> "face.read"
7411 | `Face_update -> "face.update"
7412 | `Face_delete -> "face.delete"
7413 | `Folder_read -> "folder.read"
7414 | `Job_create -> "job.create"
7415 | `Job_read -> "job.read"
7416 | `Library_create -> "library.create"
7417 | `Library_read -> "library.read"
7418 | `Library_update -> "library.update"
7419 | `Library_delete -> "library.delete"
7420 | `Library_statistics -> "library.statistics"
7421 | `Timeline_read -> "timeline.read"
7422 | `Timeline_download -> "timeline.download"
7423 | `Maintenance -> "maintenance"
7424 | `Map_read -> "map.read"
7425 | `Map_search -> "map.search"
7426 | `Memory_create -> "memory.create"
7427 | `Memory_read -> "memory.read"
7428 | `Memory_update -> "memory.update"
7429 | `Memory_delete -> "memory.delete"
7430 | `Memory_statistics -> "memory.statistics"
7431 | `Memory_asset_create -> "memoryAsset.create"
7432 | `Memory_asset_delete -> "memoryAsset.delete"
7433 | `Notification_create -> "notification.create"
7434 | `Notification_read -> "notification.read"
7435 | `Notification_update -> "notification.update"
7436 | `Notification_delete -> "notification.delete"
7437 | `Partner_create -> "partner.create"
7438 | `Partner_read -> "partner.read"
7439 | `Partner_update -> "partner.update"
7440 | `Partner_delete -> "partner.delete"
7441 | `Person_create -> "person.create"
7442 | `Person_read -> "person.read"
7443 | `Person_update -> "person.update"
7444 | `Person_delete -> "person.delete"
7445 | `Person_statistics -> "person.statistics"
7446 | `Person_merge -> "person.merge"
7447 | `Person_reassign -> "person.reassign"
7448 | `Pin_code_create -> "pinCode.create"
7449 | `Pin_code_update -> "pinCode.update"
7450 | `Pin_code_delete -> "pinCode.delete"
7451 | `Plugin_create -> "plugin.create"
7452 | `Plugin_read -> "plugin.read"
7453 | `Plugin_update -> "plugin.update"
7454 | `Plugin_delete -> "plugin.delete"
7455 | `Server_about -> "server.about"
7456 | `Server_apk_links -> "server.apkLinks"
7457 | `Server_storage -> "server.storage"
7458 | `Server_statistics -> "server.statistics"
7459 | `Server_version_check -> "server.versionCheck"
7460 | `Server_license_read -> "serverLicense.read"
7461 | `Server_license_update -> "serverLicense.update"
7462 | `Server_license_delete -> "serverLicense.delete"
7463 | `Session_create -> "session.create"
7464 | `Session_read -> "session.read"
7465 | `Session_update -> "session.update"
7466 | `Session_delete -> "session.delete"
7467 | `Session_lock -> "session.lock"
7468 | `Shared_link_create -> "sharedLink.create"
7469 | `Shared_link_read -> "sharedLink.read"
7470 | `Shared_link_update -> "sharedLink.update"
7471 | `Shared_link_delete -> "sharedLink.delete"
7472 | `Stack_create -> "stack.create"
7473 | `Stack_read -> "stack.read"
7474 | `Stack_update -> "stack.update"
7475 | `Stack_delete -> "stack.delete"
7476 | `Sync_stream -> "sync.stream"
7477 | `Sync_checkpoint_read -> "syncCheckpoint.read"
7478 | `Sync_checkpoint_update -> "syncCheckpoint.update"
7479 | `Sync_checkpoint_delete -> "syncCheckpoint.delete"
7480 | `System_config_read -> "systemConfig.read"
7481 | `System_config_update -> "systemConfig.update"
7482 | `System_metadata_read -> "systemMetadata.read"
7483 | `System_metadata_update -> "systemMetadata.update"
7484 | `Tag_create -> "tag.create"
7485 | `Tag_read -> "tag.read"
7486 | `Tag_update -> "tag.update"
7487 | `Tag_delete -> "tag.delete"
7488 | `Tag_asset -> "tag.asset"
7489 | `User_read -> "user.read"
7490 | `User_update -> "user.update"
7491 | `User_license_create -> "userLicense.create"
7492 | `User_license_read -> "userLicense.read"
7493 | `User_license_update -> "userLicense.update"
7494 | `User_license_delete -> "userLicense.delete"
7495 | `User_onboarding_read -> "userOnboarding.read"
7496 | `User_onboarding_update -> "userOnboarding.update"
7497 | `User_onboarding_delete -> "userOnboarding.delete"
7498 | `User_preference_read -> "userPreference.read"
7499 | `User_preference_update -> "userPreference.update"
7500 | `User_profile_image_create -> "userProfileImage.create"
7501 | `User_profile_image_read -> "userProfileImage.read"
7502 | `User_profile_image_update -> "userProfileImage.update"
7503 | `User_profile_image_delete -> "userProfileImage.delete"
7504 | `Queue_read -> "queue.read"
7505 | `Queue_update -> "queue.update"
7506 | `Queue_job_create -> "queueJob.create"
7507 | `Queue_job_read -> "queueJob.read"
7508 | `Queue_job_update -> "queueJob.update"
7509 | `Queue_job_delete -> "queueJob.delete"
7510 | `Workflow_create -> "workflow.create"
7511 | `Workflow_read -> "workflow.read"
7512 | `Workflow_update -> "workflow.update"
7513 | `Workflow_delete -> "workflow.delete"
7514 | `Admin_user_create -> "adminUser.create"
7515 | `Admin_user_read -> "adminUser.read"
7516 | `Admin_user_update -> "adminUser.update"
7517 | `Admin_user_delete -> "adminUser.delete"
7518 | `Admin_session_read -> "adminSession.read"
7519 | `Admin_auth_unlink_all -> "adminAuth.unlinkAll")
7520 end
7521end
7522
7523module Apikey = struct
7524 module Types = struct
7525 module UpdateDto = struct
7526 type t = {
7527 name : string option;
7528 permissions : Permission.T.t list option;
7529 }
7530 end
7531
7532 module ResponseDto = struct
7533 type t = {
7534 created_at : Ptime.t;
7535 id : string;
7536 name : string;
7537 permissions : Permission.T.t list;
7538 updated_at : Ptime.t;
7539 }
7540 end
7541
7542 module CreateDto = struct
7543 type t = {
7544 name : string option;
7545 permissions : Permission.T.t list;
7546 }
7547 end
7548 end
7549
7550 module UpdateDto = struct
7551 include Types.UpdateDto
7552
7553 let v ?name ?permissions () = { name; permissions }
7554
7555 let name t = t.name
7556 let permissions t = t.permissions
7557
7558 let jsont : t Jsont.t =
7559 Jsont.Object.map ~kind:"APIKeyUpdateDto"
7560 (fun name permissions -> { name; permissions })
7561 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
7562 |> Jsont.Object.opt_mem "permissions" (Openapi.Runtime.validated_list ~min_items:1 Permission.T.jsont) ~enc:(fun r -> r.permissions)
7563 |> Jsont.Object.skip_unknown
7564 |> Jsont.Object.finish
7565 end
7566
7567 module ResponseDto = struct
7568 include Types.ResponseDto
7569
7570 let v ~created_at ~id ~name ~permissions ~updated_at () = { created_at; id; name; permissions; updated_at }
7571
7572 let created_at t = t.created_at
7573 let id t = t.id
7574 let name t = t.name
7575 let permissions t = t.permissions
7576 let updated_at t = t.updated_at
7577
7578 let jsont : t Jsont.t =
7579 Jsont.Object.map ~kind:"APIKeyResponseDto"
7580 (fun created_at id name permissions updated_at -> { created_at; id; name; permissions; updated_at })
7581 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
7582 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
7583 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
7584 |> Jsont.Object.mem "permissions" (Jsont.list Permission.T.jsont) ~enc:(fun r -> r.permissions)
7585 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
7586 |> Jsont.Object.skip_unknown
7587 |> Jsont.Object.finish
7588 end
7589
7590 module CreateDto = struct
7591 include Types.CreateDto
7592
7593 let v ~permissions ?name () = { name; permissions }
7594
7595 let name t = t.name
7596 let permissions t = t.permissions
7597
7598 let jsont : t Jsont.t =
7599 Jsont.Object.map ~kind:"APIKeyCreateDto"
7600 (fun name permissions -> { name; permissions })
7601 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
7602 |> Jsont.Object.mem "permissions" (Openapi.Runtime.validated_list ~min_items:1 Permission.T.jsont) ~enc:(fun r -> r.permissions)
7603 |> Jsont.Object.skip_unknown
7604 |> Jsont.Object.finish
7605 end
7606
7607 (** List all API keys
7608
7609 Retrieve all API keys of the current user. *)
7610 let get_api_keys client () =
7611 let op_name = "get_api_keys" in
7612 let url_path = "/api-keys" in
7613 let query = "" in
7614 let url = client.base_url ^ url_path ^ query in
7615 let response =
7616 try Requests.get client.session url
7617 with Eio.Io _ as ex ->
7618 let bt = Printexc.get_raw_backtrace () in
7619 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
7620 in
7621 if Requests.Response.ok response then
7622 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7623 else
7624 let body = Requests.Response.text response in
7625 let parsed_body =
7626 match Jsont_bytesrw.decode_string Jsont.json body with
7627 | Ok json -> Some (Openapi.Runtime.Json json)
7628 | Error _ -> Some (Openapi.Runtime.Raw body)
7629 in
7630 raise (Openapi.Runtime.Api_error {
7631 operation = op_name;
7632 method_ = "GET";
7633 url;
7634 status = Requests.Response.status_code response;
7635 body;
7636 parsed_body;
7637 })
7638
7639 (** Retrieve the current API key
7640
7641 Retrieve the API key that is used to access this endpoint. *)
7642 let get_my_api_key client () =
7643 let op_name = "get_my_api_key" in
7644 let url_path = "/api-keys/me" in
7645 let query = "" in
7646 let url = client.base_url ^ url_path ^ query in
7647 let response =
7648 try Requests.get client.session url
7649 with Eio.Io _ as ex ->
7650 let bt = Printexc.get_raw_backtrace () in
7651 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
7652 in
7653 if Requests.Response.ok response then
7654 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7655 else
7656 let body = Requests.Response.text response in
7657 let parsed_body =
7658 match Jsont_bytesrw.decode_string Jsont.json body with
7659 | Ok json -> Some (Openapi.Runtime.Json json)
7660 | Error _ -> Some (Openapi.Runtime.Raw body)
7661 in
7662 raise (Openapi.Runtime.Api_error {
7663 operation = op_name;
7664 method_ = "GET";
7665 url;
7666 status = Requests.Response.status_code response;
7667 body;
7668 parsed_body;
7669 })
7670
7671 (** Retrieve an API key
7672
7673 Retrieve an API key by its ID. The current user must own this API key. *)
7674 let get_api_key ~id client () =
7675 let op_name = "get_api_key" in
7676 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/api-keys/{id}" in
7677 let query = "" in
7678 let url = client.base_url ^ url_path ^ query in
7679 let response =
7680 try Requests.get client.session url
7681 with Eio.Io _ as ex ->
7682 let bt = Printexc.get_raw_backtrace () in
7683 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
7684 in
7685 if Requests.Response.ok response then
7686 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7687 else
7688 let body = Requests.Response.text response in
7689 let parsed_body =
7690 match Jsont_bytesrw.decode_string Jsont.json body with
7691 | Ok json -> Some (Openapi.Runtime.Json json)
7692 | Error _ -> Some (Openapi.Runtime.Raw body)
7693 in
7694 raise (Openapi.Runtime.Api_error {
7695 operation = op_name;
7696 method_ = "GET";
7697 url;
7698 status = Requests.Response.status_code response;
7699 body;
7700 parsed_body;
7701 })
7702
7703 (** Update an API key
7704
7705 Updates the name and permissions of an API key by its ID. The current user must own this API key. *)
7706 let update_api_key ~id ~body client () =
7707 let op_name = "update_api_key" in
7708 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/api-keys/{id}" in
7709 let query = "" in
7710 let url = client.base_url ^ url_path ^ query in
7711 let response =
7712 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
7713 with Eio.Io _ as ex ->
7714 let bt = Printexc.get_raw_backtrace () in
7715 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
7716 in
7717 if Requests.Response.ok response then
7718 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7719 else
7720 let body = Requests.Response.text response in
7721 let parsed_body =
7722 match Jsont_bytesrw.decode_string Jsont.json body with
7723 | Ok json -> Some (Openapi.Runtime.Json json)
7724 | Error _ -> Some (Openapi.Runtime.Raw body)
7725 in
7726 raise (Openapi.Runtime.Api_error {
7727 operation = op_name;
7728 method_ = "PUT";
7729 url;
7730 status = Requests.Response.status_code response;
7731 body;
7732 parsed_body;
7733 })
7734end
7735
7736module ApikeyCreate = struct
7737 module Types = struct
7738 module ResponseDto = struct
7739 type t = {
7740 api_key : Apikey.ResponseDto.t;
7741 secret : string;
7742 }
7743 end
7744 end
7745
7746 module ResponseDto = struct
7747 include Types.ResponseDto
7748
7749 let v ~api_key ~secret () = { api_key; secret }
7750
7751 let api_key t = t.api_key
7752 let secret t = t.secret
7753
7754 let jsont : t Jsont.t =
7755 Jsont.Object.map ~kind:"APIKeyCreateResponseDto"
7756 (fun api_key secret -> { api_key; secret })
7757 |> Jsont.Object.mem "apiKey" Apikey.ResponseDto.jsont ~enc:(fun r -> r.api_key)
7758 |> Jsont.Object.mem "secret" Jsont.string ~enc:(fun r -> r.secret)
7759 |> Jsont.Object.skip_unknown
7760 |> Jsont.Object.finish
7761 end
7762
7763 (** Create an API key
7764
7765 Creates a new API key. It will be limited to the permissions specified. *)
7766 let create_api_key ~body client () =
7767 let op_name = "create_api_key" in
7768 let url_path = "/api-keys" in
7769 let query = "" in
7770 let url = client.base_url ^ url_path ^ query in
7771 let response =
7772 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Apikey.CreateDto.jsont body)) url
7773 with Eio.Io _ as ex ->
7774 let bt = Printexc.get_raw_backtrace () in
7775 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
7776 in
7777 if Requests.Response.ok response then
7778 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7779 else
7780 let body = Requests.Response.text response in
7781 let parsed_body =
7782 match Jsont_bytesrw.decode_string Jsont.json body with
7783 | Ok json -> Some (Openapi.Runtime.Json json)
7784 | Error _ -> Some (Openapi.Runtime.Raw body)
7785 in
7786 raise (Openapi.Runtime.Api_error {
7787 operation = op_name;
7788 method_ = "POST";
7789 url;
7790 status = Requests.Response.status_code response;
7791 body;
7792 parsed_body;
7793 })
7794end
7795
7796module PeopleUpdate = struct
7797 module Types = struct
7798 module Item = struct
7799 type t = {
7800 birth_date : string option; (** Person date of birth.
7801 Note: the mobile app cannot currently set the birth date to null. *)
7802 color : string option;
7803 feature_face_asset_id : string option; (** Asset is used to get the feature face thumbnail. *)
7804 id : string; (** Person id. *)
7805 is_favorite : bool option;
7806 is_hidden : bool option; (** Person visibility *)
7807 name : string option; (** Person name. *)
7808 }
7809 end
7810 end
7811
7812 module Item = struct
7813 include Types.Item
7814
7815 let v ~id ?birth_date ?color ?feature_face_asset_id ?is_favorite ?is_hidden ?name () = { birth_date; color; feature_face_asset_id; id; is_favorite; is_hidden; name }
7816
7817 let birth_date t = t.birth_date
7818 let color t = t.color
7819 let feature_face_asset_id t = t.feature_face_asset_id
7820 let id t = t.id
7821 let is_favorite t = t.is_favorite
7822 let is_hidden t = t.is_hidden
7823 let name t = t.name
7824
7825 let jsont : t Jsont.t =
7826 Jsont.Object.map ~kind:"PeopleUpdateItem"
7827 (fun birth_date color feature_face_asset_id id is_favorite is_hidden name -> { birth_date; color; feature_face_asset_id; id; is_favorite; is_hidden; name })
7828 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_string
7829 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
7830 |> Jsont.Object.mem "color" Openapi.Runtime.nullable_string
7831 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.color)
7832 |> Jsont.Object.opt_mem "featureFaceAssetId" Jsont.string ~enc:(fun r -> r.feature_face_asset_id)
7833 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
7834 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
7835 |> Jsont.Object.opt_mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
7836 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
7837 |> Jsont.Object.skip_unknown
7838 |> Jsont.Object.finish
7839 end
7840end
7841
7842module PartnerDirection = struct
7843 module Types = struct
7844 module T = struct
7845 type t = [
7846 | `Shared_by
7847 | `Shared_with
7848 ]
7849 end
7850 end
7851
7852 module T = struct
7853 include Types.T
7854
7855 let jsont : t Jsont.t =
7856 Jsont.map Jsont.string ~kind:"PartnerDirection"
7857 ~dec:(function
7858 | "shared-by" -> `Shared_by
7859 | "shared-with" -> `Shared_with
7860 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
7861 ~enc:(function
7862 | `Shared_by -> "shared-by"
7863 | `Shared_with -> "shared-with")
7864 end
7865end
7866
7867module Onboarding = struct
7868 module Types = struct
7869 module ResponseDto = struct
7870 type t = {
7871 is_onboarded : bool;
7872 }
7873 end
7874
7875 module Dto = struct
7876 type t = {
7877 is_onboarded : bool;
7878 }
7879 end
7880 end
7881
7882 module ResponseDto = struct
7883 include Types.ResponseDto
7884
7885 let v ~is_onboarded () = { is_onboarded }
7886
7887 let is_onboarded t = t.is_onboarded
7888
7889 let jsont : t Jsont.t =
7890 Jsont.Object.map ~kind:"OnboardingResponseDto"
7891 (fun is_onboarded -> { is_onboarded })
7892 |> Jsont.Object.mem "isOnboarded" Jsont.bool ~enc:(fun r -> r.is_onboarded)
7893 |> Jsont.Object.skip_unknown
7894 |> Jsont.Object.finish
7895 end
7896
7897 module Dto = struct
7898 include Types.Dto
7899
7900 let v ~is_onboarded () = { is_onboarded }
7901
7902 let is_onboarded t = t.is_onboarded
7903
7904 let jsont : t Jsont.t =
7905 Jsont.Object.map ~kind:"OnboardingDto"
7906 (fun is_onboarded -> { is_onboarded })
7907 |> Jsont.Object.mem "isOnboarded" Jsont.bool ~enc:(fun r -> r.is_onboarded)
7908 |> Jsont.Object.skip_unknown
7909 |> Jsont.Object.finish
7910 end
7911
7912 (** Retrieve user onboarding
7913
7914 Retrieve the onboarding status of the current user. *)
7915 let get_user_onboarding client () =
7916 let op_name = "get_user_onboarding" in
7917 let url_path = "/users/me/onboarding" in
7918 let query = "" in
7919 let url = client.base_url ^ url_path ^ query in
7920 let response =
7921 try Requests.get client.session url
7922 with Eio.Io _ as ex ->
7923 let bt = Printexc.get_raw_backtrace () in
7924 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
7925 in
7926 if Requests.Response.ok response then
7927 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7928 else
7929 let body = Requests.Response.text response in
7930 let parsed_body =
7931 match Jsont_bytesrw.decode_string Jsont.json body with
7932 | Ok json -> Some (Openapi.Runtime.Json json)
7933 | Error _ -> Some (Openapi.Runtime.Raw body)
7934 in
7935 raise (Openapi.Runtime.Api_error {
7936 operation = op_name;
7937 method_ = "GET";
7938 url;
7939 status = Requests.Response.status_code response;
7940 body;
7941 parsed_body;
7942 })
7943
7944 (** Update user onboarding
7945
7946 Update the onboarding status of the current user. *)
7947 let set_user_onboarding ~body client () =
7948 let op_name = "set_user_onboarding" in
7949 let url_path = "/users/me/onboarding" in
7950 let query = "" in
7951 let url = client.base_url ^ url_path ^ query in
7952 let response =
7953 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
7954 with Eio.Io _ as ex ->
7955 let bt = Printexc.get_raw_backtrace () in
7956 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
7957 in
7958 if Requests.Response.ok response then
7959 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
7960 else
7961 let body = Requests.Response.text response in
7962 let parsed_body =
7963 match Jsont_bytesrw.decode_string Jsont.json body with
7964 | Ok json -> Some (Openapi.Runtime.Json json)
7965 | Error _ -> Some (Openapi.Runtime.Raw body)
7966 in
7967 raise (Openapi.Runtime.Api_error {
7968 operation = op_name;
7969 method_ = "PUT";
7970 url;
7971 status = Requests.Response.status_code response;
7972 body;
7973 parsed_body;
7974 })
7975end
7976
7977module OnThisDay = struct
7978 module Types = struct
7979 module Dto = struct
7980 type t = {
7981 year : float;
7982 }
7983 end
7984 end
7985
7986 module Dto = struct
7987 include Types.Dto
7988
7989 let v ~year () = { year }
7990
7991 let year t = t.year
7992
7993 let jsont : t Jsont.t =
7994 Jsont.Object.map ~kind:"OnThisDayDto"
7995 (fun year -> { year })
7996 |> Jsont.Object.mem "year" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.year)
7997 |> Jsont.Object.skip_unknown
7998 |> Jsont.Object.finish
7999 end
8000end
8001
8002module Ocr = struct
8003 module Types = struct
8004 module Config = struct
8005 type t = {
8006 enabled : bool;
8007 max_resolution : int;
8008 min_detection_score : float;
8009 min_recognition_score : float;
8010 model_name : string;
8011 }
8012 end
8013 end
8014
8015 module Config = struct
8016 include Types.Config
8017
8018 let v ~enabled ~max_resolution ~min_detection_score ~min_recognition_score ~model_name () = { enabled; max_resolution; min_detection_score; min_recognition_score; model_name }
8019
8020 let enabled t = t.enabled
8021 let max_resolution t = t.max_resolution
8022 let min_detection_score t = t.min_detection_score
8023 let min_recognition_score t = t.min_recognition_score
8024 let model_name t = t.model_name
8025
8026 let jsont : t Jsont.t =
8027 Jsont.Object.map ~kind:"OcrConfig"
8028 (fun enabled max_resolution min_detection_score min_recognition_score model_name -> { enabled; max_resolution; min_detection_score; min_recognition_score; model_name })
8029 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
8030 |> Jsont.Object.mem "maxResolution" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.max_resolution)
8031 |> Jsont.Object.mem "minDetectionScore" (Openapi.Runtime.validated_float ~minimum:0.1 ~maximum:1. Jsont.number) ~enc:(fun r -> r.min_detection_score)
8032 |> Jsont.Object.mem "minRecognitionScore" (Openapi.Runtime.validated_float ~minimum:0.1 ~maximum:1. Jsont.number) ~enc:(fun r -> r.min_recognition_score)
8033 |> Jsont.Object.mem "modelName" Jsont.string ~enc:(fun r -> r.model_name)
8034 |> Jsont.Object.skip_unknown
8035 |> Jsont.Object.finish
8036 end
8037end
8038
8039module OauthTokenEndpointAuthMethod = struct
8040 module Types = struct
8041 module T = struct
8042 type t = [
8043 | `Client_secret_post
8044 | `Client_secret_basic
8045 ]
8046 end
8047 end
8048
8049 module T = struct
8050 include Types.T
8051
8052 let jsont : t Jsont.t =
8053 Jsont.map Jsont.string ~kind:"OAuthTokenEndpointAuthMethod"
8054 ~dec:(function
8055 | "client_secret_post" -> `Client_secret_post
8056 | "client_secret_basic" -> `Client_secret_basic
8057 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8058 ~enc:(function
8059 | `Client_secret_post -> "client_secret_post"
8060 | `Client_secret_basic -> "client_secret_basic")
8061 end
8062end
8063
8064module SystemConfigOauth = struct
8065 module Types = struct
8066 module Dto = struct
8067 type t = {
8068 auto_launch : bool;
8069 auto_register : bool;
8070 button_text : string;
8071 client_id : string;
8072 client_secret : string;
8073 default_storage_quota : int64 option;
8074 enabled : bool;
8075 issuer_url : string;
8076 mobile_override_enabled : bool;
8077 mobile_redirect_uri : string;
8078 profile_signing_algorithm : string;
8079 role_claim : string;
8080 scope : string;
8081 signing_algorithm : string;
8082 storage_label_claim : string;
8083 storage_quota_claim : string;
8084 timeout : int;
8085 token_endpoint_auth_method : OauthTokenEndpointAuthMethod.T.t;
8086 }
8087 end
8088 end
8089
8090 module Dto = struct
8091 include Types.Dto
8092
8093 let v ~auto_launch ~auto_register ~button_text ~client_id ~client_secret ~enabled ~issuer_url ~mobile_override_enabled ~mobile_redirect_uri ~profile_signing_algorithm ~role_claim ~scope ~signing_algorithm ~storage_label_claim ~storage_quota_claim ~timeout ~token_endpoint_auth_method ?default_storage_quota () = { auto_launch; auto_register; button_text; client_id; client_secret; default_storage_quota; enabled; issuer_url; mobile_override_enabled; mobile_redirect_uri; profile_signing_algorithm; role_claim; scope; signing_algorithm; storage_label_claim; storage_quota_claim; timeout; token_endpoint_auth_method }
8094
8095 let auto_launch t = t.auto_launch
8096 let auto_register t = t.auto_register
8097 let button_text t = t.button_text
8098 let client_id t = t.client_id
8099 let client_secret t = t.client_secret
8100 let default_storage_quota t = t.default_storage_quota
8101 let enabled t = t.enabled
8102 let issuer_url t = t.issuer_url
8103 let mobile_override_enabled t = t.mobile_override_enabled
8104 let mobile_redirect_uri t = t.mobile_redirect_uri
8105 let profile_signing_algorithm t = t.profile_signing_algorithm
8106 let role_claim t = t.role_claim
8107 let scope t = t.scope
8108 let signing_algorithm t = t.signing_algorithm
8109 let storage_label_claim t = t.storage_label_claim
8110 let storage_quota_claim t = t.storage_quota_claim
8111 let timeout t = t.timeout
8112 let token_endpoint_auth_method t = t.token_endpoint_auth_method
8113
8114 let jsont : t Jsont.t =
8115 Jsont.Object.map ~kind:"SystemConfigOAuthDto"
8116 (fun auto_launch auto_register button_text client_id client_secret default_storage_quota enabled issuer_url mobile_override_enabled mobile_redirect_uri profile_signing_algorithm role_claim scope signing_algorithm storage_label_claim storage_quota_claim timeout token_endpoint_auth_method -> { auto_launch; auto_register; button_text; client_id; client_secret; default_storage_quota; enabled; issuer_url; mobile_override_enabled; mobile_redirect_uri; profile_signing_algorithm; role_claim; scope; signing_algorithm; storage_label_claim; storage_quota_claim; timeout; token_endpoint_auth_method })
8117 |> Jsont.Object.mem "autoLaunch" Jsont.bool ~enc:(fun r -> r.auto_launch)
8118 |> Jsont.Object.mem "autoRegister" Jsont.bool ~enc:(fun r -> r.auto_register)
8119 |> Jsont.Object.mem "buttonText" Jsont.string ~enc:(fun r -> r.button_text)
8120 |> Jsont.Object.mem "clientId" Jsont.string ~enc:(fun r -> r.client_id)
8121 |> Jsont.Object.mem "clientSecret" Jsont.string ~enc:(fun r -> r.client_secret)
8122 |> Jsont.Object.mem "defaultStorageQuota" (Openapi.Runtime.nullable_any Jsont.int64)
8123 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.default_storage_quota)
8124 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
8125 |> Jsont.Object.mem "issuerUrl" Jsont.string ~enc:(fun r -> r.issuer_url)
8126 |> Jsont.Object.mem "mobileOverrideEnabled" Jsont.bool ~enc:(fun r -> r.mobile_override_enabled)
8127 |> Jsont.Object.mem "mobileRedirectUri" Jsont.string ~enc:(fun r -> r.mobile_redirect_uri)
8128 |> Jsont.Object.mem "profileSigningAlgorithm" Jsont.string ~enc:(fun r -> r.profile_signing_algorithm)
8129 |> Jsont.Object.mem "roleClaim" Jsont.string ~enc:(fun r -> r.role_claim)
8130 |> Jsont.Object.mem "scope" Jsont.string ~enc:(fun r -> r.scope)
8131 |> Jsont.Object.mem "signingAlgorithm" Jsont.string ~enc:(fun r -> r.signing_algorithm)
8132 |> Jsont.Object.mem "storageLabelClaim" Jsont.string ~enc:(fun r -> r.storage_label_claim)
8133 |> Jsont.Object.mem "storageQuotaClaim" Jsont.string ~enc:(fun r -> r.storage_quota_claim)
8134 |> Jsont.Object.mem "timeout" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.timeout)
8135 |> Jsont.Object.mem "tokenEndpointAuthMethod" OauthTokenEndpointAuthMethod.T.jsont ~enc:(fun r -> r.token_endpoint_auth_method)
8136 |> Jsont.Object.skip_unknown
8137 |> Jsont.Object.finish
8138 end
8139end
8140
8141module OauthConfig = struct
8142 module Types = struct
8143 module Dto = struct
8144 type t = {
8145 code_challenge : string option;
8146 redirect_uri : string;
8147 state : string option;
8148 }
8149 end
8150 end
8151
8152 module Dto = struct
8153 include Types.Dto
8154
8155 let v ~redirect_uri ?code_challenge ?state () = { code_challenge; redirect_uri; state }
8156
8157 let code_challenge t = t.code_challenge
8158 let redirect_uri t = t.redirect_uri
8159 let state t = t.state
8160
8161 let jsont : t Jsont.t =
8162 Jsont.Object.map ~kind:"OAuthConfigDto"
8163 (fun code_challenge redirect_uri state -> { code_challenge; redirect_uri; state })
8164 |> Jsont.Object.opt_mem "codeChallenge" Jsont.string ~enc:(fun r -> r.code_challenge)
8165 |> Jsont.Object.mem "redirectUri" Jsont.string ~enc:(fun r -> r.redirect_uri)
8166 |> Jsont.Object.opt_mem "state" Jsont.string ~enc:(fun r -> r.state)
8167 |> Jsont.Object.skip_unknown
8168 |> Jsont.Object.finish
8169 end
8170end
8171
8172module OauthAuthorize = struct
8173 module Types = struct
8174 module ResponseDto = struct
8175 type t = {
8176 url : string;
8177 }
8178 end
8179 end
8180
8181 module ResponseDto = struct
8182 include Types.ResponseDto
8183
8184 let v ~url () = { url }
8185
8186 let url t = t.url
8187
8188 let jsont : t Jsont.t =
8189 Jsont.Object.map ~kind:"OAuthAuthorizeResponseDto"
8190 (fun url -> { url })
8191 |> Jsont.Object.mem "url" Jsont.string ~enc:(fun r -> r.url)
8192 |> Jsont.Object.skip_unknown
8193 |> Jsont.Object.finish
8194 end
8195
8196 (** Start OAuth
8197
8198 Initiate the OAuth authorization process. *)
8199 let start_oauth ~body client () =
8200 let op_name = "start_oauth" in
8201 let url_path = "/oauth/authorize" in
8202 let query = "" in
8203 let url = client.base_url ^ url_path ^ query in
8204 let response =
8205 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json OauthConfig.Dto.jsont body)) url
8206 with Eio.Io _ as ex ->
8207 let bt = Printexc.get_raw_backtrace () in
8208 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
8209 in
8210 if Requests.Response.ok response then
8211 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
8212 else
8213 let body = Requests.Response.text response in
8214 let parsed_body =
8215 match Jsont_bytesrw.decode_string Jsont.json body with
8216 | Ok json -> Some (Openapi.Runtime.Json json)
8217 | Error _ -> Some (Openapi.Runtime.Raw body)
8218 in
8219 raise (Openapi.Runtime.Api_error {
8220 operation = op_name;
8221 method_ = "POST";
8222 url;
8223 status = Requests.Response.status_code response;
8224 body;
8225 parsed_body;
8226 })
8227end
8228
8229module OauthCallback = struct
8230 module Types = struct
8231 module Dto = struct
8232 type t = {
8233 code_verifier : string option;
8234 state : string option;
8235 url : string;
8236 }
8237 end
8238 end
8239
8240 module Dto = struct
8241 include Types.Dto
8242
8243 let v ~url ?code_verifier ?state () = { code_verifier; state; url }
8244
8245 let code_verifier t = t.code_verifier
8246 let state t = t.state
8247 let url t = t.url
8248
8249 let jsont : t Jsont.t =
8250 Jsont.Object.map ~kind:"OAuthCallbackDto"
8251 (fun code_verifier state url -> { code_verifier; state; url })
8252 |> Jsont.Object.opt_mem "codeVerifier" Jsont.string ~enc:(fun r -> r.code_verifier)
8253 |> Jsont.Object.opt_mem "state" Jsont.string ~enc:(fun r -> r.state)
8254 |> Jsont.Object.mem "url" Jsont.string ~enc:(fun r -> r.url)
8255 |> Jsont.Object.skip_unknown
8256 |> Jsont.Object.finish
8257 end
8258end
8259
8260module NotificationUpdateAll = struct
8261 module Types = struct
8262 module Dto = struct
8263 type t = {
8264 ids : string list;
8265 read_at : Ptime.t option;
8266 }
8267 end
8268 end
8269
8270 module Dto = struct
8271 include Types.Dto
8272
8273 let v ~ids ?read_at () = { ids; read_at }
8274
8275 let ids t = t.ids
8276 let read_at t = t.read_at
8277
8278 let jsont : t Jsont.t =
8279 Jsont.Object.map ~kind:"NotificationUpdateAllDto"
8280 (fun ids read_at -> { ids; read_at })
8281 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
8282 |> Jsont.Object.mem "readAt" Openapi.Runtime.nullable_ptime
8283 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.read_at)
8284 |> Jsont.Object.skip_unknown
8285 |> Jsont.Object.finish
8286 end
8287end
8288
8289module NotificationLevel = struct
8290 module Types = struct
8291 module T = struct
8292 type t = [
8293 | `Success
8294 | `Error
8295 | `Warning
8296 | `Info
8297 ]
8298 end
8299 end
8300
8301 module T = struct
8302 include Types.T
8303
8304 let jsont : t Jsont.t =
8305 Jsont.map Jsont.string ~kind:"NotificationLevel"
8306 ~dec:(function
8307 | "success" -> `Success
8308 | "error" -> `Error
8309 | "warning" -> `Warning
8310 | "info" -> `Info
8311 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8312 ~enc:(function
8313 | `Success -> "success"
8314 | `Error -> "error"
8315 | `Warning -> "warning"
8316 | `Info -> "info")
8317 end
8318end
8319
8320module Notification = struct
8321 module Types = struct
8322 module UpdateDto = struct
8323 type t = {
8324 read_at : Ptime.t option;
8325 }
8326 end
8327
8328 module Type = struct
8329 type t = [
8330 | `Job_failed
8331 | `Backup_failed
8332 | `System_message
8333 | `Album_invite
8334 | `Album_update
8335 | `Custom
8336 ]
8337 end
8338
8339 module Dto = struct
8340 type t = {
8341 created_at : Ptime.t;
8342 data : Jsont.json option;
8343 description : string option;
8344 id : string;
8345 level : NotificationLevel.T.t;
8346 read_at : Ptime.t option;
8347 title : string;
8348 type_ : Type.t;
8349 }
8350 end
8351
8352 module CreateDto = struct
8353 type t = {
8354 data : Jsont.json option;
8355 description : string option;
8356 level : NotificationLevel.T.t option;
8357 read_at : Ptime.t option;
8358 title : string;
8359 type_ : Type.t option;
8360 user_id : string;
8361 }
8362 end
8363 end
8364
8365 module UpdateDto = struct
8366 include Types.UpdateDto
8367
8368 let v ?read_at () = { read_at }
8369
8370 let read_at t = t.read_at
8371
8372 let jsont : t Jsont.t =
8373 Jsont.Object.map ~kind:"NotificationUpdateDto"
8374 (fun read_at -> { read_at })
8375 |> Jsont.Object.mem "readAt" Openapi.Runtime.nullable_ptime
8376 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.read_at)
8377 |> Jsont.Object.skip_unknown
8378 |> Jsont.Object.finish
8379 end
8380
8381 module Type = struct
8382 include Types.Type
8383
8384 let jsont : t Jsont.t =
8385 Jsont.map Jsont.string ~kind:"NotificationType"
8386 ~dec:(function
8387 | "JobFailed" -> `Job_failed
8388 | "BackupFailed" -> `Backup_failed
8389 | "SystemMessage" -> `System_message
8390 | "AlbumInvite" -> `Album_invite
8391 | "AlbumUpdate" -> `Album_update
8392 | "Custom" -> `Custom
8393 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8394 ~enc:(function
8395 | `Job_failed -> "JobFailed"
8396 | `Backup_failed -> "BackupFailed"
8397 | `System_message -> "SystemMessage"
8398 | `Album_invite -> "AlbumInvite"
8399 | `Album_update -> "AlbumUpdate"
8400 | `Custom -> "Custom")
8401 end
8402
8403 module Dto = struct
8404 include Types.Dto
8405
8406 let v ~created_at ~id ~level ~title ~type_ ?data ?description ?read_at () = { created_at; data; description; id; level; read_at; title; type_ }
8407
8408 let created_at t = t.created_at
8409 let data t = t.data
8410 let description t = t.description
8411 let id t = t.id
8412 let level t = t.level
8413 let read_at t = t.read_at
8414 let title t = t.title
8415 let type_ t = t.type_
8416
8417 let jsont : t Jsont.t =
8418 Jsont.Object.map ~kind:"NotificationDto"
8419 (fun created_at data description id level read_at title type_ -> { created_at; data; description; id; level; read_at; title; type_ })
8420 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
8421 |> Jsont.Object.opt_mem "data" Jsont.json ~enc:(fun r -> r.data)
8422 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
8423 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
8424 |> Jsont.Object.mem "level" NotificationLevel.T.jsont ~enc:(fun r -> r.level)
8425 |> Jsont.Object.opt_mem "readAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.read_at)
8426 |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
8427 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
8428 |> Jsont.Object.skip_unknown
8429 |> Jsont.Object.finish
8430 end
8431
8432 module CreateDto = struct
8433 include Types.CreateDto
8434
8435 let v ~title ~user_id ?data ?description ?level ?read_at ?type_ () = { data; description; level; read_at; title; type_; user_id }
8436
8437 let data t = t.data
8438 let description t = t.description
8439 let level t = t.level
8440 let read_at t = t.read_at
8441 let title t = t.title
8442 let type_ t = t.type_
8443 let user_id t = t.user_id
8444
8445 let jsont : t Jsont.t =
8446 Jsont.Object.map ~kind:"NotificationCreateDto"
8447 (fun data description level read_at title type_ user_id -> { data; description; level; read_at; title; type_; user_id })
8448 |> Jsont.Object.opt_mem "data" Jsont.json ~enc:(fun r -> r.data)
8449 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
8450 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
8451 |> Jsont.Object.opt_mem "level" NotificationLevel.T.jsont ~enc:(fun r -> r.level)
8452 |> Jsont.Object.mem "readAt" Openapi.Runtime.nullable_ptime
8453 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.read_at)
8454 |> Jsont.Object.mem "title" Jsont.string ~enc:(fun r -> r.title)
8455 |> Jsont.Object.opt_mem "type" Type.jsont ~enc:(fun r -> r.type_)
8456 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
8457 |> Jsont.Object.skip_unknown
8458 |> Jsont.Object.finish
8459 end
8460
8461 (** Create a notification
8462
8463 Create a new notification for a specific user. *)
8464 let create_notification ~body client () =
8465 let op_name = "create_notification" in
8466 let url_path = "/admin/notifications" in
8467 let query = "" in
8468 let url = client.base_url ^ url_path ^ query in
8469 let response =
8470 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
8471 with Eio.Io _ as ex ->
8472 let bt = Printexc.get_raw_backtrace () in
8473 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
8474 in
8475 if Requests.Response.ok response then
8476 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
8477 else
8478 let body = Requests.Response.text response in
8479 let parsed_body =
8480 match Jsont_bytesrw.decode_string Jsont.json body with
8481 | Ok json -> Some (Openapi.Runtime.Json json)
8482 | Error _ -> Some (Openapi.Runtime.Raw body)
8483 in
8484 raise (Openapi.Runtime.Api_error {
8485 operation = op_name;
8486 method_ = "POST";
8487 url;
8488 status = Requests.Response.status_code response;
8489 body;
8490 parsed_body;
8491 })
8492
8493 (** Retrieve notifications
8494
8495 Retrieve a list of notifications. *)
8496 let get_notifications ?id ?level ?type_ ?unread client () =
8497 let op_name = "get_notifications" in
8498 let url_path = "/notifications" in
8499 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"id" ~value:id; Openapi.Runtime.Query.optional ~key:"level" ~value:level; Openapi.Runtime.Query.optional ~key:"type" ~value:type_; Openapi.Runtime.Query.optional ~key:"unread" ~value:unread]) in
8500 let url = client.base_url ^ url_path ^ query in
8501 let response =
8502 try Requests.get client.session url
8503 with Eio.Io _ as ex ->
8504 let bt = Printexc.get_raw_backtrace () in
8505 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
8506 in
8507 if Requests.Response.ok response then
8508 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
8509 else
8510 let body = Requests.Response.text response in
8511 let parsed_body =
8512 match Jsont_bytesrw.decode_string Jsont.json body with
8513 | Ok json -> Some (Openapi.Runtime.Json json)
8514 | Error _ -> Some (Openapi.Runtime.Raw body)
8515 in
8516 raise (Openapi.Runtime.Api_error {
8517 operation = op_name;
8518 method_ = "GET";
8519 url;
8520 status = Requests.Response.status_code response;
8521 body;
8522 parsed_body;
8523 })
8524
8525 (** Get a notification
8526
8527 Retrieve a specific notification identified by id. *)
8528 let get_notification ~id client () =
8529 let op_name = "get_notification" in
8530 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/notifications/{id}" in
8531 let query = "" in
8532 let url = client.base_url ^ url_path ^ query in
8533 let response =
8534 try Requests.get client.session url
8535 with Eio.Io _ as ex ->
8536 let bt = Printexc.get_raw_backtrace () in
8537 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
8538 in
8539 if Requests.Response.ok response then
8540 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
8541 else
8542 let body = Requests.Response.text response in
8543 let parsed_body =
8544 match Jsont_bytesrw.decode_string Jsont.json body with
8545 | Ok json -> Some (Openapi.Runtime.Json json)
8546 | Error _ -> Some (Openapi.Runtime.Raw body)
8547 in
8548 raise (Openapi.Runtime.Api_error {
8549 operation = op_name;
8550 method_ = "GET";
8551 url;
8552 status = Requests.Response.status_code response;
8553 body;
8554 parsed_body;
8555 })
8556
8557 (** Update a notification
8558
8559 Update a specific notification to set its read status. *)
8560 let update_notification ~id ~body client () =
8561 let op_name = "update_notification" in
8562 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/notifications/{id}" in
8563 let query = "" in
8564 let url = client.base_url ^ url_path ^ query in
8565 let response =
8566 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
8567 with Eio.Io _ as ex ->
8568 let bt = Printexc.get_raw_backtrace () in
8569 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
8570 in
8571 if Requests.Response.ok response then
8572 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
8573 else
8574 let body = Requests.Response.text response in
8575 let parsed_body =
8576 match Jsont_bytesrw.decode_string Jsont.json body with
8577 | Ok json -> Some (Openapi.Runtime.Json json)
8578 | Error _ -> Some (Openapi.Runtime.Raw body)
8579 in
8580 raise (Openapi.Runtime.Api_error {
8581 operation = op_name;
8582 method_ = "PUT";
8583 url;
8584 status = Requests.Response.status_code response;
8585 body;
8586 parsed_body;
8587 })
8588end
8589
8590module NotificationDeleteAll = struct
8591 module Types = struct
8592 module Dto = struct
8593 type t = {
8594 ids : string list;
8595 }
8596 end
8597 end
8598
8599 module Dto = struct
8600 include Types.Dto
8601
8602 let v ~ids () = { ids }
8603
8604 let ids t = t.ids
8605
8606 let jsont : t Jsont.t =
8607 Jsont.Object.map ~kind:"NotificationDeleteAllDto"
8608 (fun ids -> { ids })
8609 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
8610 |> Jsont.Object.skip_unknown
8611 |> Jsont.Object.finish
8612 end
8613end
8614
8615module MirrorAxis = struct
8616 module Types = struct
8617 module T = struct
8618 (** Axis to mirror along *)
8619 type t = [
8620 | `Horizontal
8621 | `Vertical
8622 ]
8623 end
8624 end
8625
8626 module T = struct
8627 include Types.T
8628
8629 let jsont : t Jsont.t =
8630 Jsont.map Jsont.string ~kind:"MirrorAxis"
8631 ~dec:(function
8632 | "horizontal" -> `Horizontal
8633 | "vertical" -> `Vertical
8634 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8635 ~enc:(function
8636 | `Horizontal -> "horizontal"
8637 | `Vertical -> "vertical")
8638 end
8639end
8640
8641module MirrorParameters = struct
8642 module Types = struct
8643 module T = struct
8644 type t = {
8645 axis : MirrorAxis.T.t; (** Axis to mirror along *)
8646 }
8647 end
8648 end
8649
8650 module T = struct
8651 include Types.T
8652
8653 let v ~axis () = { axis }
8654
8655 let axis t = t.axis
8656
8657 let jsont : t Jsont.t =
8658 Jsont.Object.map ~kind:"MirrorParameters"
8659 (fun axis -> { axis })
8660 |> Jsont.Object.mem "axis" MirrorAxis.T.jsont ~enc:(fun r -> r.axis)
8661 |> Jsont.Object.skip_unknown
8662 |> Jsont.Object.finish
8663 end
8664end
8665
8666module MergePerson = struct
8667 module Types = struct
8668 module Dto = struct
8669 type t = {
8670 ids : string list;
8671 }
8672 end
8673 end
8674
8675 module Dto = struct
8676 include Types.Dto
8677
8678 let v ~ids () = { ids }
8679
8680 let ids t = t.ids
8681
8682 let jsont : t Jsont.t =
8683 Jsont.Object.map ~kind:"MergePersonDto"
8684 (fun ids -> { ids })
8685 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
8686 |> Jsont.Object.skip_unknown
8687 |> Jsont.Object.finish
8688 end
8689end
8690
8691module MemoryStatistics = struct
8692 module Types = struct
8693 module ResponseDto = struct
8694 type t = {
8695 total : int;
8696 }
8697 end
8698 end
8699
8700 module ResponseDto = struct
8701 include Types.ResponseDto
8702
8703 let v ~total () = { total }
8704
8705 let total t = t.total
8706
8707 let jsont : t Jsont.t =
8708 Jsont.Object.map ~kind:"MemoryStatisticsResponseDto"
8709 (fun total -> { total })
8710 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
8711 |> Jsont.Object.skip_unknown
8712 |> Jsont.Object.finish
8713 end
8714
8715 (** Retrieve memories statistics
8716
8717 Retrieve statistics about memories, such as total count and other relevant metrics.
8718 @param size Number of memories to return
8719 *)
8720 let memories_statistics ?for_ ?is_saved ?is_trashed ?order ?size ?type_ client () =
8721 let op_name = "memories_statistics" in
8722 let url_path = "/memories/statistics" in
8723 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"for" ~value:for_; Openapi.Runtime.Query.optional ~key:"isSaved" ~value:is_saved; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"order" ~value:order; Openapi.Runtime.Query.optional ~key:"size" ~value:size; Openapi.Runtime.Query.optional ~key:"type" ~value:type_]) in
8724 let url = client.base_url ^ url_path ^ query in
8725 let response =
8726 try Requests.get client.session url
8727 with Eio.Io _ as ex ->
8728 let bt = Printexc.get_raw_backtrace () in
8729 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
8730 in
8731 if Requests.Response.ok response then
8732 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
8733 else
8734 let body = Requests.Response.text response in
8735 let parsed_body =
8736 match Jsont_bytesrw.decode_string Jsont.json body with
8737 | Ok json -> Some (Openapi.Runtime.Json json)
8738 | Error _ -> Some (Openapi.Runtime.Raw body)
8739 in
8740 raise (Openapi.Runtime.Api_error {
8741 operation = op_name;
8742 method_ = "GET";
8743 url;
8744 status = Requests.Response.status_code response;
8745 body;
8746 parsed_body;
8747 })
8748end
8749
8750module MemorySearchOrder = struct
8751 module Types = struct
8752 module T = struct
8753 type t = [
8754 | `Asc
8755 | `Desc
8756 | `Random
8757 ]
8758 end
8759 end
8760
8761 module T = struct
8762 include Types.T
8763
8764 let jsont : t Jsont.t =
8765 Jsont.map Jsont.string ~kind:"MemorySearchOrder"
8766 ~dec:(function
8767 | "asc" -> `Asc
8768 | "desc" -> `Desc
8769 | "random" -> `Random
8770 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8771 ~enc:(function
8772 | `Asc -> "asc"
8773 | `Desc -> "desc"
8774 | `Random -> "random")
8775 end
8776end
8777
8778module Memories = struct
8779 module Types = struct
8780 module Update = struct
8781 type t = {
8782 duration : int option;
8783 enabled : bool option;
8784 }
8785 end
8786
8787 module Response = struct
8788 type t = {
8789 duration : int;
8790 enabled : bool;
8791 }
8792 end
8793 end
8794
8795 module Update = struct
8796 include Types.Update
8797
8798 let v ?duration ?enabled () = { duration; enabled }
8799
8800 let duration t = t.duration
8801 let enabled t = t.enabled
8802
8803 let jsont : t Jsont.t =
8804 Jsont.Object.map ~kind:"MemoriesUpdate"
8805 (fun duration enabled -> { duration; enabled })
8806 |> Jsont.Object.opt_mem "duration" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.duration)
8807 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
8808 |> Jsont.Object.skip_unknown
8809 |> Jsont.Object.finish
8810 end
8811
8812 module Response = struct
8813 include Types.Response
8814
8815 let v ?(duration=5) ?(enabled=true) () = { duration; enabled }
8816
8817 let duration t = t.duration
8818 let enabled t = t.enabled
8819
8820 let jsont : t Jsont.t =
8821 Jsont.Object.map ~kind:"MemoriesResponse"
8822 (fun duration enabled -> { duration; enabled })
8823 |> Jsont.Object.mem "duration" Jsont.int ~dec_absent:5 ~enc:(fun r -> r.duration)
8824 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.enabled)
8825 |> Jsont.Object.skip_unknown
8826 |> Jsont.Object.finish
8827 end
8828end
8829
8830module MapReverseGeocode = struct
8831 module Types = struct
8832 module ResponseDto = struct
8833 type t = {
8834 city : string option;
8835 country : string option;
8836 state : string option;
8837 }
8838 end
8839 end
8840
8841 module ResponseDto = struct
8842 include Types.ResponseDto
8843
8844 let v ?city ?country ?state () = { city; country; state }
8845
8846 let city t = t.city
8847 let country t = t.country
8848 let state t = t.state
8849
8850 let jsont : t Jsont.t =
8851 Jsont.Object.map ~kind:"MapReverseGeocodeResponseDto"
8852 (fun city country state -> { city; country; state })
8853 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
8854 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
8855 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
8856 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
8857 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
8858 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
8859 |> Jsont.Object.skip_unknown
8860 |> Jsont.Object.finish
8861 end
8862
8863 (** Reverse geocode coordinates
8864
8865 Retrieve location information (e.g., city, country) for given latitude and longitude coordinates. *)
8866 let reverse_geocode ~lat ~lon client () =
8867 let op_name = "reverse_geocode" in
8868 let url_path = "/map/reverse-geocode" in
8869 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"lat" ~value:lat; Openapi.Runtime.Query.singleton ~key:"lon" ~value:lon]) in
8870 let url = client.base_url ^ url_path ^ query in
8871 let response =
8872 try Requests.get client.session url
8873 with Eio.Io _ as ex ->
8874 let bt = Printexc.get_raw_backtrace () in
8875 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
8876 in
8877 if Requests.Response.ok response then
8878 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
8879 else
8880 let body = Requests.Response.text response in
8881 let parsed_body =
8882 match Jsont_bytesrw.decode_string Jsont.json body with
8883 | Ok json -> Some (Openapi.Runtime.Json json)
8884 | Error _ -> Some (Openapi.Runtime.Raw body)
8885 in
8886 raise (Openapi.Runtime.Api_error {
8887 operation = op_name;
8888 method_ = "GET";
8889 url;
8890 status = Requests.Response.status_code response;
8891 body;
8892 parsed_body;
8893 })
8894end
8895
8896module MapMarker = struct
8897 module Types = struct
8898 module ResponseDto = struct
8899 type t = {
8900 city : string option;
8901 country : string option;
8902 id : string;
8903 lat : float;
8904 lon : float;
8905 state : string option;
8906 }
8907 end
8908 end
8909
8910 module ResponseDto = struct
8911 include Types.ResponseDto
8912
8913 let v ~id ~lat ~lon ?city ?country ?state () = { city; country; id; lat; lon; state }
8914
8915 let city t = t.city
8916 let country t = t.country
8917 let id t = t.id
8918 let lat t = t.lat
8919 let lon t = t.lon
8920 let state t = t.state
8921
8922 let jsont : t Jsont.t =
8923 Jsont.Object.map ~kind:"MapMarkerResponseDto"
8924 (fun city country id lat lon state -> { city; country; id; lat; lon; state })
8925 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
8926 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
8927 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
8928 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
8929 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
8930 |> Jsont.Object.mem "lat" Jsont.number ~enc:(fun r -> r.lat)
8931 |> Jsont.Object.mem "lon" Jsont.number ~enc:(fun r -> r.lon)
8932 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
8933 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
8934 |> Jsont.Object.skip_unknown
8935 |> Jsont.Object.finish
8936 end
8937
8938 (** Retrieve map markers
8939
8940 Retrieve a list of latitude and longitude coordinates for every asset with location data. *)
8941 let get_map_markers ?file_created_after ?file_created_before ?is_archived ?is_favorite ?with_partners ?with_shared_albums client () =
8942 let op_name = "get_map_markers" in
8943 let url_path = "/map/markers" in
8944 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"fileCreatedAfter" ~value:file_created_after; Openapi.Runtime.Query.optional ~key:"fileCreatedBefore" ~value:file_created_before; Openapi.Runtime.Query.optional ~key:"isArchived" ~value:is_archived; Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"withPartners" ~value:with_partners; Openapi.Runtime.Query.optional ~key:"withSharedAlbums" ~value:with_shared_albums]) in
8945 let url = client.base_url ^ url_path ^ query in
8946 let response =
8947 try Requests.get client.session url
8948 with Eio.Io _ as ex ->
8949 let bt = Printexc.get_raw_backtrace () in
8950 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
8951 in
8952 if Requests.Response.ok response then
8953 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
8954 else
8955 let body = Requests.Response.text response in
8956 let parsed_body =
8957 match Jsont_bytesrw.decode_string Jsont.json body with
8958 | Ok json -> Some (Openapi.Runtime.Json json)
8959 | Error _ -> Some (Openapi.Runtime.Raw body)
8960 in
8961 raise (Openapi.Runtime.Api_error {
8962 operation = op_name;
8963 method_ = "GET";
8964 url;
8965 status = Requests.Response.status_code response;
8966 body;
8967 parsed_body;
8968 })
8969end
8970
8971module ManualJobName = struct
8972 module Types = struct
8973 module T = struct
8974 type t = [
8975 | `Person_cleanup
8976 | `Tag_cleanup
8977 | `User_cleanup
8978 | `Memory_cleanup
8979 | `Memory_create
8980 | `Backup_database
8981 ]
8982 end
8983 end
8984
8985 module T = struct
8986 include Types.T
8987
8988 let jsont : t Jsont.t =
8989 Jsont.map Jsont.string ~kind:"ManualJobName"
8990 ~dec:(function
8991 | "person-cleanup" -> `Person_cleanup
8992 | "tag-cleanup" -> `Tag_cleanup
8993 | "user-cleanup" -> `User_cleanup
8994 | "memory-cleanup" -> `Memory_cleanup
8995 | "memory-create" -> `Memory_create
8996 | "backup-database" -> `Backup_database
8997 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
8998 ~enc:(function
8999 | `Person_cleanup -> "person-cleanup"
9000 | `Tag_cleanup -> "tag-cleanup"
9001 | `User_cleanup -> "user-cleanup"
9002 | `Memory_cleanup -> "memory-cleanup"
9003 | `Memory_create -> "memory-create"
9004 | `Backup_database -> "backup-database")
9005 end
9006end
9007
9008module Job = struct
9009 module Types = struct
9010 module CreateDto = struct
9011 type t = {
9012 name : ManualJobName.T.t;
9013 }
9014 end
9015 end
9016
9017 module CreateDto = struct
9018 include Types.CreateDto
9019
9020 let v ~name () = { name }
9021
9022 let name t = t.name
9023
9024 let jsont : t Jsont.t =
9025 Jsont.Object.map ~kind:"JobCreateDto"
9026 (fun name -> { name })
9027 |> Jsont.Object.mem "name" ManualJobName.T.jsont ~enc:(fun r -> r.name)
9028 |> Jsont.Object.skip_unknown
9029 |> Jsont.Object.finish
9030 end
9031end
9032
9033module MaintenanceLogin = struct
9034 module Types = struct
9035 module Dto = struct
9036 type t = {
9037 token : string option;
9038 }
9039 end
9040 end
9041
9042 module Dto = struct
9043 include Types.Dto
9044
9045 let v ?token () = { token }
9046
9047 let token t = t.token
9048
9049 let jsont : t Jsont.t =
9050 Jsont.Object.map ~kind:"MaintenanceLoginDto"
9051 (fun token -> { token })
9052 |> Jsont.Object.opt_mem "token" Jsont.string ~enc:(fun r -> r.token)
9053 |> Jsont.Object.skip_unknown
9054 |> Jsont.Object.finish
9055 end
9056end
9057
9058module MaintenanceAuth = struct
9059 module Types = struct
9060 module Dto = struct
9061 type t = {
9062 username : string;
9063 }
9064 end
9065 end
9066
9067 module Dto = struct
9068 include Types.Dto
9069
9070 let v ~username () = { username }
9071
9072 let username t = t.username
9073
9074 let jsont : t Jsont.t =
9075 Jsont.Object.map ~kind:"MaintenanceAuthDto"
9076 (fun username -> { username })
9077 |> Jsont.Object.mem "username" Jsont.string ~enc:(fun r -> r.username)
9078 |> Jsont.Object.skip_unknown
9079 |> Jsont.Object.finish
9080 end
9081
9082 (** Log into maintenance mode
9083
9084 Login with maintenance token or cookie to receive current information and perform further actions. *)
9085 let maintenance_login ~body client () =
9086 let op_name = "maintenance_login" in
9087 let url_path = "/admin/maintenance/login" in
9088 let query = "" in
9089 let url = client.base_url ^ url_path ^ query in
9090 let response =
9091 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json MaintenanceLogin.Dto.jsont body)) url
9092 with Eio.Io _ as ex ->
9093 let bt = Printexc.get_raw_backtrace () in
9094 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
9095 in
9096 if Requests.Response.ok response then
9097 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
9098 else
9099 let body = Requests.Response.text response in
9100 let parsed_body =
9101 match Jsont_bytesrw.decode_string Jsont.json body with
9102 | Ok json -> Some (Openapi.Runtime.Json json)
9103 | Error _ -> Some (Openapi.Runtime.Raw body)
9104 in
9105 raise (Openapi.Runtime.Api_error {
9106 operation = op_name;
9107 method_ = "POST";
9108 url;
9109 status = Requests.Response.status_code response;
9110 body;
9111 parsed_body;
9112 })
9113end
9114
9115module MaintenanceAction = struct
9116 module Types = struct
9117 module T = struct
9118 type t = [
9119 | `Start
9120 | `End_
9121 | `Select_database_restore
9122 | `Restore_database
9123 ]
9124 end
9125 end
9126
9127 module T = struct
9128 include Types.T
9129
9130 let jsont : t Jsont.t =
9131 Jsont.map Jsont.string ~kind:"MaintenanceAction"
9132 ~dec:(function
9133 | "start" -> `Start
9134 | "end" -> `End_
9135 | "select_database_restore" -> `Select_database_restore
9136 | "restore_database" -> `Restore_database
9137 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
9138 ~enc:(function
9139 | `Start -> "start"
9140 | `End_ -> "end"
9141 | `Select_database_restore -> "select_database_restore"
9142 | `Restore_database -> "restore_database")
9143 end
9144end
9145
9146module SetMaintenanceMode = struct
9147 module Types = struct
9148 module Dto = struct
9149 type t = {
9150 action : MaintenanceAction.T.t;
9151 restore_backup_filename : string option;
9152 }
9153 end
9154 end
9155
9156 module Dto = struct
9157 include Types.Dto
9158
9159 let v ~action ?restore_backup_filename () = { action; restore_backup_filename }
9160
9161 let action t = t.action
9162 let restore_backup_filename t = t.restore_backup_filename
9163
9164 let jsont : t Jsont.t =
9165 Jsont.Object.map ~kind:"SetMaintenanceModeDto"
9166 (fun action restore_backup_filename -> { action; restore_backup_filename })
9167 |> Jsont.Object.mem "action" MaintenanceAction.T.jsont ~enc:(fun r -> r.action)
9168 |> Jsont.Object.opt_mem "restoreBackupFilename" Jsont.string ~enc:(fun r -> r.restore_backup_filename)
9169 |> Jsont.Object.skip_unknown
9170 |> Jsont.Object.finish
9171 end
9172end
9173
9174module MaintenanceStatus = struct
9175 module Types = struct
9176 module ResponseDto = struct
9177 type t = {
9178 action : MaintenanceAction.T.t;
9179 active : bool;
9180 error : string option;
9181 progress : float option;
9182 task : string option;
9183 }
9184 end
9185 end
9186
9187 module ResponseDto = struct
9188 include Types.ResponseDto
9189
9190 let v ~action ~active ?error ?progress ?task () = { action; active; error; progress; task }
9191
9192 let action t = t.action
9193 let active t = t.active
9194 let error t = t.error
9195 let progress t = t.progress
9196 let task t = t.task
9197
9198 let jsont : t Jsont.t =
9199 Jsont.Object.map ~kind:"MaintenanceStatusResponseDto"
9200 (fun action active error progress task -> { action; active; error; progress; task })
9201 |> Jsont.Object.mem "action" MaintenanceAction.T.jsont ~enc:(fun r -> r.action)
9202 |> Jsont.Object.mem "active" Jsont.bool ~enc:(fun r -> r.active)
9203 |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
9204 |> Jsont.Object.opt_mem "progress" Jsont.number ~enc:(fun r -> r.progress)
9205 |> Jsont.Object.opt_mem "task" Jsont.string ~enc:(fun r -> r.task)
9206 |> Jsont.Object.skip_unknown
9207 |> Jsont.Object.finish
9208 end
9209
9210 (** Get maintenance mode status
9211
9212 Fetch information about the currently running maintenance action. *)
9213 let get_maintenance_status client () =
9214 let op_name = "get_maintenance_status" in
9215 let url_path = "/admin/maintenance/status" in
9216 let query = "" in
9217 let url = client.base_url ^ url_path ^ query in
9218 let response =
9219 try Requests.get client.session url
9220 with Eio.Io _ as ex ->
9221 let bt = Printexc.get_raw_backtrace () in
9222 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
9223 in
9224 if Requests.Response.ok response then
9225 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9226 else
9227 let body = Requests.Response.text response in
9228 let parsed_body =
9229 match Jsont_bytesrw.decode_string Jsont.json body with
9230 | Ok json -> Some (Openapi.Runtime.Json json)
9231 | Error _ -> Some (Openapi.Runtime.Raw body)
9232 in
9233 raise (Openapi.Runtime.Api_error {
9234 operation = op_name;
9235 method_ = "GET";
9236 url;
9237 status = Requests.Response.status_code response;
9238 body;
9239 parsed_body;
9240 })
9241end
9242
9243module MachineLearningAvailabilityChecks = struct
9244 module Types = struct
9245 module Dto = struct
9246 type t = {
9247 enabled : bool;
9248 interval : float;
9249 timeout : float;
9250 }
9251 end
9252 end
9253
9254 module Dto = struct
9255 include Types.Dto
9256
9257 let v ~enabled ~interval ~timeout () = { enabled; interval; timeout }
9258
9259 let enabled t = t.enabled
9260 let interval t = t.interval
9261 let timeout t = t.timeout
9262
9263 let jsont : t Jsont.t =
9264 Jsont.Object.map ~kind:"MachineLearningAvailabilityChecksDto"
9265 (fun enabled interval timeout -> { enabled; interval; timeout })
9266 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
9267 |> Jsont.Object.mem "interval" Jsont.number ~enc:(fun r -> r.interval)
9268 |> Jsont.Object.mem "timeout" Jsont.number ~enc:(fun r -> r.timeout)
9269 |> Jsont.Object.skip_unknown
9270 |> Jsont.Object.finish
9271 end
9272end
9273
9274module Logout = struct
9275 module Types = struct
9276 module ResponseDto = struct
9277 type t = {
9278 redirect_uri : string;
9279 successful : bool;
9280 }
9281 end
9282 end
9283
9284 module ResponseDto = struct
9285 include Types.ResponseDto
9286
9287 let v ~redirect_uri ~successful () = { redirect_uri; successful }
9288
9289 let redirect_uri t = t.redirect_uri
9290 let successful t = t.successful
9291
9292 let jsont : t Jsont.t =
9293 Jsont.Object.map ~kind:"LogoutResponseDto"
9294 (fun redirect_uri successful -> { redirect_uri; successful })
9295 |> Jsont.Object.mem "redirectUri" Jsont.string ~enc:(fun r -> r.redirect_uri)
9296 |> Jsont.Object.mem "successful" Jsont.bool ~enc:(fun r -> r.successful)
9297 |> Jsont.Object.skip_unknown
9298 |> Jsont.Object.finish
9299 end
9300
9301 (** Logout
9302
9303 Logout the current user and invalidate the session token. *)
9304 let logout client () =
9305 let op_name = "logout" in
9306 let url_path = "/auth/logout" in
9307 let query = "" in
9308 let url = client.base_url ^ url_path ^ query in
9309 let response =
9310 try Requests.post client.session url
9311 with Eio.Io _ as ex ->
9312 let bt = Printexc.get_raw_backtrace () in
9313 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
9314 in
9315 if Requests.Response.ok response then
9316 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9317 else
9318 let body = Requests.Response.text response in
9319 let parsed_body =
9320 match Jsont_bytesrw.decode_string Jsont.json body with
9321 | Ok json -> Some (Openapi.Runtime.Json json)
9322 | Error _ -> Some (Openapi.Runtime.Raw body)
9323 in
9324 raise (Openapi.Runtime.Api_error {
9325 operation = op_name;
9326 method_ = "POST";
9327 url;
9328 status = Requests.Response.status_code response;
9329 body;
9330 parsed_body;
9331 })
9332end
9333
9334module LoginCredential = struct
9335 module Types = struct
9336 module Dto = struct
9337 type t = {
9338 email : string;
9339 password : string;
9340 }
9341 end
9342 end
9343
9344 module Dto = struct
9345 include Types.Dto
9346
9347 let v ~email ~password () = { email; password }
9348
9349 let email t = t.email
9350 let password t = t.password
9351
9352 let jsont : t Jsont.t =
9353 Jsont.Object.map ~kind:"LoginCredentialDto"
9354 (fun email password -> { email; password })
9355 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
9356 |> Jsont.Object.mem "password" Jsont.string ~enc:(fun r -> r.password)
9357 |> Jsont.Object.skip_unknown
9358 |> Jsont.Object.finish
9359 end
9360end
9361
9362module Login = struct
9363 module Types = struct
9364 module ResponseDto = struct
9365 type t = {
9366 access_token : string;
9367 is_admin : bool;
9368 is_onboarded : bool;
9369 name : string;
9370 profile_image_path : string;
9371 should_change_password : bool;
9372 user_email : string;
9373 user_id : string;
9374 }
9375 end
9376 end
9377
9378 module ResponseDto = struct
9379 include Types.ResponseDto
9380
9381 let v ~access_token ~is_admin ~is_onboarded ~name ~profile_image_path ~should_change_password ~user_email ~user_id () = { access_token; is_admin; is_onboarded; name; profile_image_path; should_change_password; user_email; user_id }
9382
9383 let access_token t = t.access_token
9384 let is_admin t = t.is_admin
9385 let is_onboarded t = t.is_onboarded
9386 let name t = t.name
9387 let profile_image_path t = t.profile_image_path
9388 let should_change_password t = t.should_change_password
9389 let user_email t = t.user_email
9390 let user_id t = t.user_id
9391
9392 let jsont : t Jsont.t =
9393 Jsont.Object.map ~kind:"LoginResponseDto"
9394 (fun access_token is_admin is_onboarded name profile_image_path should_change_password user_email user_id -> { access_token; is_admin; is_onboarded; name; profile_image_path; should_change_password; user_email; user_id })
9395 |> Jsont.Object.mem "accessToken" Jsont.string ~enc:(fun r -> r.access_token)
9396 |> Jsont.Object.mem "isAdmin" Jsont.bool ~enc:(fun r -> r.is_admin)
9397 |> Jsont.Object.mem "isOnboarded" Jsont.bool ~enc:(fun r -> r.is_onboarded)
9398 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
9399 |> Jsont.Object.mem "profileImagePath" Jsont.string ~enc:(fun r -> r.profile_image_path)
9400 |> Jsont.Object.mem "shouldChangePassword" Jsont.bool ~enc:(fun r -> r.should_change_password)
9401 |> Jsont.Object.mem "userEmail" Jsont.string ~enc:(fun r -> r.user_email)
9402 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
9403 |> Jsont.Object.skip_unknown
9404 |> Jsont.Object.finish
9405 end
9406
9407 (** Login
9408
9409 Login with username and password and receive a session token. *)
9410 let login ~body client () =
9411 let op_name = "login" in
9412 let url_path = "/auth/login" in
9413 let query = "" in
9414 let url = client.base_url ^ url_path ^ query in
9415 let response =
9416 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json LoginCredential.Dto.jsont body)) url
9417 with Eio.Io _ as ex ->
9418 let bt = Printexc.get_raw_backtrace () in
9419 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
9420 in
9421 if Requests.Response.ok response then
9422 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9423 else
9424 let body = Requests.Response.text response in
9425 let parsed_body =
9426 match Jsont_bytesrw.decode_string Jsont.json body with
9427 | Ok json -> Some (Openapi.Runtime.Json json)
9428 | Error _ -> Some (Openapi.Runtime.Raw body)
9429 in
9430 raise (Openapi.Runtime.Api_error {
9431 operation = op_name;
9432 method_ = "POST";
9433 url;
9434 status = Requests.Response.status_code response;
9435 body;
9436 parsed_body;
9437 })
9438
9439 (** Finish OAuth
9440
9441 Complete the OAuth authorization process by exchanging the authorization code for a session token. *)
9442 let finish_oauth ~body client () =
9443 let op_name = "finish_oauth" in
9444 let url_path = "/oauth/callback" in
9445 let query = "" in
9446 let url = client.base_url ^ url_path ^ query in
9447 let response =
9448 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json OauthCallback.Dto.jsont body)) url
9449 with Eio.Io _ as ex ->
9450 let bt = Printexc.get_raw_backtrace () in
9451 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
9452 in
9453 if Requests.Response.ok response then
9454 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9455 else
9456 let body = Requests.Response.text response in
9457 let parsed_body =
9458 match Jsont_bytesrw.decode_string Jsont.json body with
9459 | Ok json -> Some (Openapi.Runtime.Json json)
9460 | Error _ -> Some (Openapi.Runtime.Raw body)
9461 in
9462 raise (Openapi.Runtime.Api_error {
9463 operation = op_name;
9464 method_ = "POST";
9465 url;
9466 status = Requests.Response.status_code response;
9467 body;
9468 parsed_body;
9469 })
9470end
9471
9472module LogLevel = struct
9473 module Types = struct
9474 module T = struct
9475 type t = [
9476 | `Verbose
9477 | `Debug
9478 | `Log
9479 | `Warn
9480 | `Error
9481 | `Fatal
9482 ]
9483 end
9484 end
9485
9486 module T = struct
9487 include Types.T
9488
9489 let jsont : t Jsont.t =
9490 Jsont.map Jsont.string ~kind:"LogLevel"
9491 ~dec:(function
9492 | "verbose" -> `Verbose
9493 | "debug" -> `Debug
9494 | "log" -> `Log
9495 | "warn" -> `Warn
9496 | "error" -> `Error
9497 | "fatal" -> `Fatal
9498 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
9499 ~enc:(function
9500 | `Verbose -> "verbose"
9501 | `Debug -> "debug"
9502 | `Log -> "log"
9503 | `Warn -> "warn"
9504 | `Error -> "error"
9505 | `Fatal -> "fatal")
9506 end
9507end
9508
9509module SystemConfigLogging = struct
9510 module Types = struct
9511 module Dto = struct
9512 type t = {
9513 enabled : bool;
9514 level : LogLevel.T.t;
9515 }
9516 end
9517 end
9518
9519 module Dto = struct
9520 include Types.Dto
9521
9522 let v ~enabled ~level () = { enabled; level }
9523
9524 let enabled t = t.enabled
9525 let level t = t.level
9526
9527 let jsont : t Jsont.t =
9528 Jsont.Object.map ~kind:"SystemConfigLoggingDto"
9529 (fun enabled level -> { enabled; level })
9530 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
9531 |> Jsont.Object.mem "level" LogLevel.T.jsont ~enc:(fun r -> r.level)
9532 |> Jsont.Object.skip_unknown
9533 |> Jsont.Object.finish
9534 end
9535end
9536
9537module LicenseKey = struct
9538 module Types = struct
9539 module Dto = struct
9540 type t = {
9541 activation_key : string;
9542 license_key : string;
9543 }
9544 end
9545 end
9546
9547 module Dto = struct
9548 include Types.Dto
9549
9550 let v ~activation_key ~license_key () = { activation_key; license_key }
9551
9552 let activation_key t = t.activation_key
9553 let license_key t = t.license_key
9554
9555 let jsont : t Jsont.t =
9556 Jsont.Object.map ~kind:"LicenseKeyDto"
9557 (fun activation_key license_key -> { activation_key; license_key })
9558 |> Jsont.Object.mem "activationKey" Jsont.string ~enc:(fun r -> r.activation_key)
9559 |> Jsont.Object.mem "licenseKey" (Openapi.Runtime.validated_string ~pattern:"/IM(SV|CL)(-[\\dA-Za-z]{4}){8}/" Jsont.string) ~enc:(fun r -> r.license_key)
9560 |> Jsont.Object.skip_unknown
9561 |> Jsont.Object.finish
9562 end
9563end
9564
9565module License = struct
9566 module Types = struct
9567 module ResponseDto = struct
9568 type t = {
9569 activated_at : Ptime.t;
9570 activation_key : string;
9571 license_key : string;
9572 }
9573 end
9574 end
9575
9576 module ResponseDto = struct
9577 include Types.ResponseDto
9578
9579 let v ~activated_at ~activation_key ~license_key () = { activated_at; activation_key; license_key }
9580
9581 let activated_at t = t.activated_at
9582 let activation_key t = t.activation_key
9583 let license_key t = t.license_key
9584
9585 let jsont : t Jsont.t =
9586 Jsont.Object.map ~kind:"LicenseResponseDto"
9587 (fun activated_at activation_key license_key -> { activated_at; activation_key; license_key })
9588 |> Jsont.Object.mem "activatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.activated_at)
9589 |> Jsont.Object.mem "activationKey" Jsont.string ~enc:(fun r -> r.activation_key)
9590 |> Jsont.Object.mem "licenseKey" (Openapi.Runtime.validated_string ~pattern:"/IM(SV|CL)(-[\\dA-Za-z]{4}){8}/" Jsont.string) ~enc:(fun r -> r.license_key)
9591 |> Jsont.Object.skip_unknown
9592 |> Jsont.Object.finish
9593 end
9594
9595 (** Get product key
9596
9597 Retrieve information about whether the server currently has a product key registered. *)
9598 let get_server_license client () =
9599 let op_name = "get_server_license" in
9600 let url_path = "/server/license" in
9601 let query = "" in
9602 let url = client.base_url ^ url_path ^ query in
9603 let response =
9604 try Requests.get client.session url
9605 with Eio.Io _ as ex ->
9606 let bt = Printexc.get_raw_backtrace () in
9607 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
9608 in
9609 if Requests.Response.ok response then
9610 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9611 else
9612 let body = Requests.Response.text response in
9613 let parsed_body =
9614 match Jsont_bytesrw.decode_string Jsont.json body with
9615 | Ok json -> Some (Openapi.Runtime.Json json)
9616 | Error _ -> Some (Openapi.Runtime.Raw body)
9617 in
9618 raise (Openapi.Runtime.Api_error {
9619 operation = op_name;
9620 method_ = "GET";
9621 url;
9622 status = Requests.Response.status_code response;
9623 body;
9624 parsed_body;
9625 })
9626
9627 (** Set server product key
9628
9629 Validate and set the server product key if successful. *)
9630 let set_server_license ~body client () =
9631 let op_name = "set_server_license" in
9632 let url_path = "/server/license" in
9633 let query = "" in
9634 let url = client.base_url ^ url_path ^ query in
9635 let response =
9636 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json LicenseKey.Dto.jsont body)) url
9637 with Eio.Io _ as ex ->
9638 let bt = Printexc.get_raw_backtrace () in
9639 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
9640 in
9641 if Requests.Response.ok response then
9642 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9643 else
9644 let body = Requests.Response.text response in
9645 let parsed_body =
9646 match Jsont_bytesrw.decode_string Jsont.json body with
9647 | Ok json -> Some (Openapi.Runtime.Json json)
9648 | Error _ -> Some (Openapi.Runtime.Raw body)
9649 in
9650 raise (Openapi.Runtime.Api_error {
9651 operation = op_name;
9652 method_ = "PUT";
9653 url;
9654 status = Requests.Response.status_code response;
9655 body;
9656 parsed_body;
9657 })
9658
9659 (** Retrieve user product key
9660
9661 Retrieve information about whether the current user has a registered product key. *)
9662 let get_user_license client () =
9663 let op_name = "get_user_license" in
9664 let url_path = "/users/me/license" in
9665 let query = "" in
9666 let url = client.base_url ^ url_path ^ query in
9667 let response =
9668 try Requests.get client.session url
9669 with Eio.Io _ as ex ->
9670 let bt = Printexc.get_raw_backtrace () in
9671 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
9672 in
9673 if Requests.Response.ok response then
9674 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9675 else
9676 let body = Requests.Response.text response in
9677 let parsed_body =
9678 match Jsont_bytesrw.decode_string Jsont.json body with
9679 | Ok json -> Some (Openapi.Runtime.Json json)
9680 | Error _ -> Some (Openapi.Runtime.Raw body)
9681 in
9682 raise (Openapi.Runtime.Api_error {
9683 operation = op_name;
9684 method_ = "GET";
9685 url;
9686 status = Requests.Response.status_code response;
9687 body;
9688 parsed_body;
9689 })
9690
9691 (** Set user product key
9692
9693 Register a product key for the current user. *)
9694 let set_user_license ~body client () =
9695 let op_name = "set_user_license" in
9696 let url_path = "/users/me/license" in
9697 let query = "" in
9698 let url = client.base_url ^ url_path ^ query in
9699 let response =
9700 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json LicenseKey.Dto.jsont body)) url
9701 with Eio.Io _ as ex ->
9702 let bt = Printexc.get_raw_backtrace () in
9703 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
9704 in
9705 if Requests.Response.ok response then
9706 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9707 else
9708 let body = Requests.Response.text response in
9709 let parsed_body =
9710 match Jsont_bytesrw.decode_string Jsont.json body with
9711 | Ok json -> Some (Openapi.Runtime.Json json)
9712 | Error _ -> Some (Openapi.Runtime.Raw body)
9713 in
9714 raise (Openapi.Runtime.Api_error {
9715 operation = op_name;
9716 method_ = "PUT";
9717 url;
9718 status = Requests.Response.status_code response;
9719 body;
9720 parsed_body;
9721 })
9722end
9723
9724module LibraryStats = struct
9725 module Types = struct
9726 module ResponseDto = struct
9727 type t = {
9728 photos : int;
9729 total : int;
9730 usage : int64;
9731 videos : int;
9732 }
9733 end
9734 end
9735
9736 module ResponseDto = struct
9737 include Types.ResponseDto
9738
9739 let v ?(photos=0) ?(total=0) ?(usage=0L) ?(videos=0) () = { photos; total; usage; videos }
9740
9741 let photos t = t.photos
9742 let total t = t.total
9743 let usage t = t.usage
9744 let videos t = t.videos
9745
9746 let jsont : t Jsont.t =
9747 Jsont.Object.map ~kind:"LibraryStatsResponseDto"
9748 (fun photos total usage videos -> { photos; total; usage; videos })
9749 |> Jsont.Object.mem "photos" Jsont.int ~dec_absent:0 ~enc:(fun r -> r.photos)
9750 |> Jsont.Object.mem "total" Jsont.int ~dec_absent:0 ~enc:(fun r -> r.total)
9751 |> Jsont.Object.mem "usage" Jsont.int64 ~dec_absent:0L ~enc:(fun r -> r.usage)
9752 |> Jsont.Object.mem "videos" Jsont.int ~dec_absent:0 ~enc:(fun r -> r.videos)
9753 |> Jsont.Object.skip_unknown
9754 |> Jsont.Object.finish
9755 end
9756
9757 (** Retrieve library statistics
9758
9759 Retrieve statistics for a specific external library, including number of videos, images, and storage usage. *)
9760 let get_library_statistics ~id client () =
9761 let op_name = "get_library_statistics" in
9762 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}/statistics" in
9763 let query = "" in
9764 let url = client.base_url ^ url_path ^ query in
9765 let response =
9766 try Requests.get client.session url
9767 with Eio.Io _ as ex ->
9768 let bt = Printexc.get_raw_backtrace () in
9769 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
9770 in
9771 if Requests.Response.ok response then
9772 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
9773 else
9774 let body = Requests.Response.text response in
9775 let parsed_body =
9776 match Jsont_bytesrw.decode_string Jsont.json body with
9777 | Ok json -> Some (Openapi.Runtime.Json json)
9778 | Error _ -> Some (Openapi.Runtime.Raw body)
9779 in
9780 raise (Openapi.Runtime.Api_error {
9781 operation = op_name;
9782 method_ = "GET";
9783 url;
9784 status = Requests.Response.status_code response;
9785 body;
9786 parsed_body;
9787 })
9788end
9789
9790module JobSettings = struct
9791 module Types = struct
9792 module Dto = struct
9793 type t = {
9794 concurrency : int;
9795 }
9796 end
9797 end
9798
9799 module Dto = struct
9800 include Types.Dto
9801
9802 let v ~concurrency () = { concurrency }
9803
9804 let concurrency t = t.concurrency
9805
9806 let jsont : t Jsont.t =
9807 Jsont.Object.map ~kind:"JobSettingsDto"
9808 (fun concurrency -> { concurrency })
9809 |> Jsont.Object.mem "concurrency" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.concurrency)
9810 |> Jsont.Object.skip_unknown
9811 |> Jsont.Object.finish
9812 end
9813end
9814
9815module SystemConfigJob = struct
9816 module Types = struct
9817 module Dto = struct
9818 type t = {
9819 background_task : JobSettings.Dto.t;
9820 editor : JobSettings.Dto.t;
9821 face_detection : JobSettings.Dto.t;
9822 library : JobSettings.Dto.t;
9823 metadata_extraction : JobSettings.Dto.t;
9824 migration : JobSettings.Dto.t;
9825 notifications : JobSettings.Dto.t;
9826 ocr : JobSettings.Dto.t;
9827 search : JobSettings.Dto.t;
9828 sidecar : JobSettings.Dto.t;
9829 smart_search : JobSettings.Dto.t;
9830 thumbnail_generation : JobSettings.Dto.t;
9831 video_conversion : JobSettings.Dto.t;
9832 workflow : JobSettings.Dto.t;
9833 }
9834 end
9835 end
9836
9837 module Dto = struct
9838 include Types.Dto
9839
9840 let v ~background_task ~editor ~face_detection ~library ~metadata_extraction ~migration ~notifications ~ocr ~search ~sidecar ~smart_search ~thumbnail_generation ~video_conversion ~workflow () = { background_task; editor; face_detection; library; metadata_extraction; migration; notifications; ocr; search; sidecar; smart_search; thumbnail_generation; video_conversion; workflow }
9841
9842 let background_task t = t.background_task
9843 let editor t = t.editor
9844 let face_detection t = t.face_detection
9845 let library t = t.library
9846 let metadata_extraction t = t.metadata_extraction
9847 let migration t = t.migration
9848 let notifications t = t.notifications
9849 let ocr t = t.ocr
9850 let search t = t.search
9851 let sidecar t = t.sidecar
9852 let smart_search t = t.smart_search
9853 let thumbnail_generation t = t.thumbnail_generation
9854 let video_conversion t = t.video_conversion
9855 let workflow t = t.workflow
9856
9857 let jsont : t Jsont.t =
9858 Jsont.Object.map ~kind:"SystemConfigJobDto"
9859 (fun background_task editor face_detection library metadata_extraction migration notifications ocr search sidecar smart_search thumbnail_generation video_conversion workflow -> { background_task; editor; face_detection; library; metadata_extraction; migration; notifications; ocr; search; sidecar; smart_search; thumbnail_generation; video_conversion; workflow })
9860 |> Jsont.Object.mem "backgroundTask" JobSettings.Dto.jsont ~enc:(fun r -> r.background_task)
9861 |> Jsont.Object.mem "editor" JobSettings.Dto.jsont ~enc:(fun r -> r.editor)
9862 |> Jsont.Object.mem "faceDetection" JobSettings.Dto.jsont ~enc:(fun r -> r.face_detection)
9863 |> Jsont.Object.mem "library" JobSettings.Dto.jsont ~enc:(fun r -> r.library)
9864 |> Jsont.Object.mem "metadataExtraction" JobSettings.Dto.jsont ~enc:(fun r -> r.metadata_extraction)
9865 |> Jsont.Object.mem "migration" JobSettings.Dto.jsont ~enc:(fun r -> r.migration)
9866 |> Jsont.Object.mem "notifications" JobSettings.Dto.jsont ~enc:(fun r -> r.notifications)
9867 |> Jsont.Object.mem "ocr" JobSettings.Dto.jsont ~enc:(fun r -> r.ocr)
9868 |> Jsont.Object.mem "search" JobSettings.Dto.jsont ~enc:(fun r -> r.search)
9869 |> Jsont.Object.mem "sidecar" JobSettings.Dto.jsont ~enc:(fun r -> r.sidecar)
9870 |> Jsont.Object.mem "smartSearch" JobSettings.Dto.jsont ~enc:(fun r -> r.smart_search)
9871 |> Jsont.Object.mem "thumbnailGeneration" JobSettings.Dto.jsont ~enc:(fun r -> r.thumbnail_generation)
9872 |> Jsont.Object.mem "videoConversion" JobSettings.Dto.jsont ~enc:(fun r -> r.video_conversion)
9873 |> Jsont.Object.mem "workflow" JobSettings.Dto.jsont ~enc:(fun r -> r.workflow)
9874 |> Jsont.Object.skip_unknown
9875 |> Jsont.Object.finish
9876 end
9877end
9878
9879module JobName = struct
9880 module Types = struct
9881 module T = struct
9882 type t = [
9883 | `Asset_delete
9884 | `Asset_delete_check
9885 | `Asset_detect_faces_queue_all
9886 | `Asset_detect_faces
9887 | `Asset_detect_duplicates_queue_all
9888 | `Asset_detect_duplicates
9889 | `Asset_edit_thumbnail_generation
9890 | `Asset_encode_video_queue_all
9891 | `Asset_encode_video
9892 | `Asset_empty_trash
9893 | `Asset_extract_metadata_queue_all
9894 | `Asset_extract_metadata
9895 | `Asset_file_migration
9896 | `Asset_generate_thumbnails_queue_all
9897 | `Asset_generate_thumbnails
9898 | `Audit_log_cleanup
9899 | `Audit_table_cleanup
9900 | `Database_backup
9901 | `Facial_recognition_queue_all
9902 | `Facial_recognition
9903 | `File_delete
9904 | `File_migration_queue_all
9905 | `Library_delete_check
9906 | `Library_delete
9907 | `Library_remove_asset
9908 | `Library_scan_assets_queue_all
9909 | `Library_sync_assets
9910 | `Library_sync_files_queue_all
9911 | `Library_sync_files
9912 | `Library_scan_queue_all
9913 | `Memory_cleanup
9914 | `Memory_generate
9915 | `Notifications_cleanup
9916 | `Notify_user_signup
9917 | `Notify_album_invite
9918 | `Notify_album_update
9919 | `User_delete
9920 | `User_delete_check
9921 | `User_sync_usage
9922 | `Person_cleanup
9923 | `Person_file_migration
9924 | `Person_generate_thumbnail
9925 | `Session_cleanup
9926 | `Send_mail
9927 | `Sidecar_queue_all
9928 | `Sidecar_check
9929 | `Sidecar_write
9930 | `Smart_search_queue_all
9931 | `Smart_search
9932 | `Storage_template_migration
9933 | `Storage_template_migration_single
9934 | `Tag_cleanup
9935 | `Version_check
9936 | `Ocr_queue_all
9937 | `Ocr
9938 | `Workflow_run
9939 ]
9940 end
9941 end
9942
9943 module T = struct
9944 include Types.T
9945
9946 let jsont : t Jsont.t =
9947 Jsont.map Jsont.string ~kind:"JobName"
9948 ~dec:(function
9949 | "AssetDelete" -> `Asset_delete
9950 | "AssetDeleteCheck" -> `Asset_delete_check
9951 | "AssetDetectFacesQueueAll" -> `Asset_detect_faces_queue_all
9952 | "AssetDetectFaces" -> `Asset_detect_faces
9953 | "AssetDetectDuplicatesQueueAll" -> `Asset_detect_duplicates_queue_all
9954 | "AssetDetectDuplicates" -> `Asset_detect_duplicates
9955 | "AssetEditThumbnailGeneration" -> `Asset_edit_thumbnail_generation
9956 | "AssetEncodeVideoQueueAll" -> `Asset_encode_video_queue_all
9957 | "AssetEncodeVideo" -> `Asset_encode_video
9958 | "AssetEmptyTrash" -> `Asset_empty_trash
9959 | "AssetExtractMetadataQueueAll" -> `Asset_extract_metadata_queue_all
9960 | "AssetExtractMetadata" -> `Asset_extract_metadata
9961 | "AssetFileMigration" -> `Asset_file_migration
9962 | "AssetGenerateThumbnailsQueueAll" -> `Asset_generate_thumbnails_queue_all
9963 | "AssetGenerateThumbnails" -> `Asset_generate_thumbnails
9964 | "AuditLogCleanup" -> `Audit_log_cleanup
9965 | "AuditTableCleanup" -> `Audit_table_cleanup
9966 | "DatabaseBackup" -> `Database_backup
9967 | "FacialRecognitionQueueAll" -> `Facial_recognition_queue_all
9968 | "FacialRecognition" -> `Facial_recognition
9969 | "FileDelete" -> `File_delete
9970 | "FileMigrationQueueAll" -> `File_migration_queue_all
9971 | "LibraryDeleteCheck" -> `Library_delete_check
9972 | "LibraryDelete" -> `Library_delete
9973 | "LibraryRemoveAsset" -> `Library_remove_asset
9974 | "LibraryScanAssetsQueueAll" -> `Library_scan_assets_queue_all
9975 | "LibrarySyncAssets" -> `Library_sync_assets
9976 | "LibrarySyncFilesQueueAll" -> `Library_sync_files_queue_all
9977 | "LibrarySyncFiles" -> `Library_sync_files
9978 | "LibraryScanQueueAll" -> `Library_scan_queue_all
9979 | "MemoryCleanup" -> `Memory_cleanup
9980 | "MemoryGenerate" -> `Memory_generate
9981 | "NotificationsCleanup" -> `Notifications_cleanup
9982 | "NotifyUserSignup" -> `Notify_user_signup
9983 | "NotifyAlbumInvite" -> `Notify_album_invite
9984 | "NotifyAlbumUpdate" -> `Notify_album_update
9985 | "UserDelete" -> `User_delete
9986 | "UserDeleteCheck" -> `User_delete_check
9987 | "UserSyncUsage" -> `User_sync_usage
9988 | "PersonCleanup" -> `Person_cleanup
9989 | "PersonFileMigration" -> `Person_file_migration
9990 | "PersonGenerateThumbnail" -> `Person_generate_thumbnail
9991 | "SessionCleanup" -> `Session_cleanup
9992 | "SendMail" -> `Send_mail
9993 | "SidecarQueueAll" -> `Sidecar_queue_all
9994 | "SidecarCheck" -> `Sidecar_check
9995 | "SidecarWrite" -> `Sidecar_write
9996 | "SmartSearchQueueAll" -> `Smart_search_queue_all
9997 | "SmartSearch" -> `Smart_search
9998 | "StorageTemplateMigration" -> `Storage_template_migration
9999 | "StorageTemplateMigrationSingle" -> `Storage_template_migration_single
10000 | "TagCleanup" -> `Tag_cleanup
10001 | "VersionCheck" -> `Version_check
10002 | "OcrQueueAll" -> `Ocr_queue_all
10003 | "Ocr" -> `Ocr
10004 | "WorkflowRun" -> `Workflow_run
10005 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
10006 ~enc:(function
10007 | `Asset_delete -> "AssetDelete"
10008 | `Asset_delete_check -> "AssetDeleteCheck"
10009 | `Asset_detect_faces_queue_all -> "AssetDetectFacesQueueAll"
10010 | `Asset_detect_faces -> "AssetDetectFaces"
10011 | `Asset_detect_duplicates_queue_all -> "AssetDetectDuplicatesQueueAll"
10012 | `Asset_detect_duplicates -> "AssetDetectDuplicates"
10013 | `Asset_edit_thumbnail_generation -> "AssetEditThumbnailGeneration"
10014 | `Asset_encode_video_queue_all -> "AssetEncodeVideoQueueAll"
10015 | `Asset_encode_video -> "AssetEncodeVideo"
10016 | `Asset_empty_trash -> "AssetEmptyTrash"
10017 | `Asset_extract_metadata_queue_all -> "AssetExtractMetadataQueueAll"
10018 | `Asset_extract_metadata -> "AssetExtractMetadata"
10019 | `Asset_file_migration -> "AssetFileMigration"
10020 | `Asset_generate_thumbnails_queue_all -> "AssetGenerateThumbnailsQueueAll"
10021 | `Asset_generate_thumbnails -> "AssetGenerateThumbnails"
10022 | `Audit_log_cleanup -> "AuditLogCleanup"
10023 | `Audit_table_cleanup -> "AuditTableCleanup"
10024 | `Database_backup -> "DatabaseBackup"
10025 | `Facial_recognition_queue_all -> "FacialRecognitionQueueAll"
10026 | `Facial_recognition -> "FacialRecognition"
10027 | `File_delete -> "FileDelete"
10028 | `File_migration_queue_all -> "FileMigrationQueueAll"
10029 | `Library_delete_check -> "LibraryDeleteCheck"
10030 | `Library_delete -> "LibraryDelete"
10031 | `Library_remove_asset -> "LibraryRemoveAsset"
10032 | `Library_scan_assets_queue_all -> "LibraryScanAssetsQueueAll"
10033 | `Library_sync_assets -> "LibrarySyncAssets"
10034 | `Library_sync_files_queue_all -> "LibrarySyncFilesQueueAll"
10035 | `Library_sync_files -> "LibrarySyncFiles"
10036 | `Library_scan_queue_all -> "LibraryScanQueueAll"
10037 | `Memory_cleanup -> "MemoryCleanup"
10038 | `Memory_generate -> "MemoryGenerate"
10039 | `Notifications_cleanup -> "NotificationsCleanup"
10040 | `Notify_user_signup -> "NotifyUserSignup"
10041 | `Notify_album_invite -> "NotifyAlbumInvite"
10042 | `Notify_album_update -> "NotifyAlbumUpdate"
10043 | `User_delete -> "UserDelete"
10044 | `User_delete_check -> "UserDeleteCheck"
10045 | `User_sync_usage -> "UserSyncUsage"
10046 | `Person_cleanup -> "PersonCleanup"
10047 | `Person_file_migration -> "PersonFileMigration"
10048 | `Person_generate_thumbnail -> "PersonGenerateThumbnail"
10049 | `Session_cleanup -> "SessionCleanup"
10050 | `Send_mail -> "SendMail"
10051 | `Sidecar_queue_all -> "SidecarQueueAll"
10052 | `Sidecar_check -> "SidecarCheck"
10053 | `Sidecar_write -> "SidecarWrite"
10054 | `Smart_search_queue_all -> "SmartSearchQueueAll"
10055 | `Smart_search -> "SmartSearch"
10056 | `Storage_template_migration -> "StorageTemplateMigration"
10057 | `Storage_template_migration_single -> "StorageTemplateMigrationSingle"
10058 | `Tag_cleanup -> "TagCleanup"
10059 | `Version_check -> "VersionCheck"
10060 | `Ocr_queue_all -> "OcrQueueAll"
10061 | `Ocr -> "Ocr"
10062 | `Workflow_run -> "WorkflowRun")
10063 end
10064end
10065
10066module QueueJob = struct
10067 module Types = struct
10068 module Status = struct
10069 type t = [
10070 | `Active
10071 | `Failed
10072 | `Completed
10073 | `Delayed
10074 | `Waiting
10075 | `Paused
10076 ]
10077 end
10078
10079 module ResponseDto = struct
10080 type t = {
10081 data : Jsont.json;
10082 id : string option;
10083 name : JobName.T.t;
10084 timestamp : int;
10085 }
10086 end
10087 end
10088
10089 module Status = struct
10090 include Types.Status
10091
10092 let jsont : t Jsont.t =
10093 Jsont.map Jsont.string ~kind:"QueueJobStatus"
10094 ~dec:(function
10095 | "active" -> `Active
10096 | "failed" -> `Failed
10097 | "completed" -> `Completed
10098 | "delayed" -> `Delayed
10099 | "waiting" -> `Waiting
10100 | "paused" -> `Paused
10101 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
10102 ~enc:(function
10103 | `Active -> "active"
10104 | `Failed -> "failed"
10105 | `Completed -> "completed"
10106 | `Delayed -> "delayed"
10107 | `Waiting -> "waiting"
10108 | `Paused -> "paused")
10109 end
10110
10111 module ResponseDto = struct
10112 include Types.ResponseDto
10113
10114 let v ~data ~name ~timestamp ?id () = { data; id; name; timestamp }
10115
10116 let data t = t.data
10117 let id t = t.id
10118 let name t = t.name
10119 let timestamp t = t.timestamp
10120
10121 let jsont : t Jsont.t =
10122 Jsont.Object.map ~kind:"QueueJobResponseDto"
10123 (fun data id name timestamp -> { data; id; name; timestamp })
10124 |> Jsont.Object.mem "data" Jsont.json ~enc:(fun r -> r.data)
10125 |> Jsont.Object.opt_mem "id" Jsont.string ~enc:(fun r -> r.id)
10126 |> Jsont.Object.mem "name" JobName.T.jsont ~enc:(fun r -> r.name)
10127 |> Jsont.Object.mem "timestamp" Jsont.int ~enc:(fun r -> r.timestamp)
10128 |> Jsont.Object.skip_unknown
10129 |> Jsont.Object.finish
10130 end
10131
10132 (** Retrieve queue jobs
10133
10134 Retrieves a list of queue jobs from the specified queue. *)
10135 let get_queue_jobs ~name ?status client () =
10136 let op_name = "get_queue_jobs" in
10137 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/queues/{name}/jobs" in
10138 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"status" ~value:status]) in
10139 let url = client.base_url ^ url_path ^ query in
10140 let response =
10141 try Requests.get client.session url
10142 with Eio.Io _ as ex ->
10143 let bt = Printexc.get_raw_backtrace () in
10144 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
10145 in
10146 if Requests.Response.ok response then
10147 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
10148 else
10149 let body = Requests.Response.text response in
10150 let parsed_body =
10151 match Jsont_bytesrw.decode_string Jsont.json body with
10152 | Ok json -> Some (Openapi.Runtime.Json json)
10153 | Error _ -> Some (Openapi.Runtime.Raw body)
10154 in
10155 raise (Openapi.Runtime.Api_error {
10156 operation = op_name;
10157 method_ = "GET";
10158 url;
10159 status = Requests.Response.status_code response;
10160 body;
10161 parsed_body;
10162 })
10163end
10164
10165module ImageFormat = struct
10166 module Types = struct
10167 module T = struct
10168 type t = [
10169 | `Jpeg
10170 | `Webp
10171 ]
10172 end
10173 end
10174
10175 module T = struct
10176 include Types.T
10177
10178 let jsont : t Jsont.t =
10179 Jsont.map Jsont.string ~kind:"ImageFormat"
10180 ~dec:(function
10181 | "jpeg" -> `Jpeg
10182 | "webp" -> `Webp
10183 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
10184 ~enc:(function
10185 | `Jpeg -> "jpeg"
10186 | `Webp -> "webp")
10187 end
10188end
10189
10190module SystemConfigGeneratedImage = struct
10191 module Types = struct
10192 module Dto = struct
10193 type t = {
10194 format : ImageFormat.T.t;
10195 progressive : bool;
10196 quality : int;
10197 size : int;
10198 }
10199 end
10200 end
10201
10202 module Dto = struct
10203 include Types.Dto
10204
10205 let v ~format ~quality ~size ?(progressive=false) () = { format; progressive; quality; size }
10206
10207 let format t = t.format
10208 let progressive t = t.progressive
10209 let quality t = t.quality
10210 let size t = t.size
10211
10212 let jsont : t Jsont.t =
10213 Jsont.Object.map ~kind:"SystemConfigGeneratedImageDto"
10214 (fun format progressive quality size -> { format; progressive; quality; size })
10215 |> Jsont.Object.mem "format" ImageFormat.T.jsont ~enc:(fun r -> r.format)
10216 |> Jsont.Object.mem "progressive" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.progressive)
10217 |> Jsont.Object.mem "quality" (Openapi.Runtime.validated_int ~minimum:1. ~maximum:100. Jsont.int) ~enc:(fun r -> r.quality)
10218 |> Jsont.Object.mem "size" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.size)
10219 |> Jsont.Object.skip_unknown
10220 |> Jsont.Object.finish
10221 end
10222end
10223
10224module SystemConfigGeneratedFullsizeImage = struct
10225 module Types = struct
10226 module Dto = struct
10227 type t = {
10228 enabled : bool;
10229 format : ImageFormat.T.t;
10230 progressive : bool;
10231 quality : int;
10232 }
10233 end
10234 end
10235
10236 module Dto = struct
10237 include Types.Dto
10238
10239 let v ~enabled ~format ~quality ?(progressive=false) () = { enabled; format; progressive; quality }
10240
10241 let enabled t = t.enabled
10242 let format t = t.format
10243 let progressive t = t.progressive
10244 let quality t = t.quality
10245
10246 let jsont : t Jsont.t =
10247 Jsont.Object.map ~kind:"SystemConfigGeneratedFullsizeImageDto"
10248 (fun enabled format progressive quality -> { enabled; format; progressive; quality })
10249 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10250 |> Jsont.Object.mem "format" ImageFormat.T.jsont ~enc:(fun r -> r.format)
10251 |> Jsont.Object.mem "progressive" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.progressive)
10252 |> Jsont.Object.mem "quality" (Openapi.Runtime.validated_int ~minimum:1. ~maximum:100. Jsont.int) ~enc:(fun r -> r.quality)
10253 |> Jsont.Object.skip_unknown
10254 |> Jsont.Object.finish
10255 end
10256end
10257
10258module Folders = struct
10259 module Types = struct
10260 module Update = struct
10261 type t = {
10262 enabled : bool option;
10263 sidebar_web : bool option;
10264 }
10265 end
10266
10267 module Response = struct
10268 type t = {
10269 enabled : bool;
10270 sidebar_web : bool;
10271 }
10272 end
10273 end
10274
10275 module Update = struct
10276 include Types.Update
10277
10278 let v ?enabled ?sidebar_web () = { enabled; sidebar_web }
10279
10280 let enabled t = t.enabled
10281 let sidebar_web t = t.sidebar_web
10282
10283 let jsont : t Jsont.t =
10284 Jsont.Object.map ~kind:"FoldersUpdate"
10285 (fun enabled sidebar_web -> { enabled; sidebar_web })
10286 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10287 |> Jsont.Object.opt_mem "sidebarWeb" Jsont.bool ~enc:(fun r -> r.sidebar_web)
10288 |> Jsont.Object.skip_unknown
10289 |> Jsont.Object.finish
10290 end
10291
10292 module Response = struct
10293 include Types.Response
10294
10295 let v ?(enabled=false) ?(sidebar_web=false) () = { enabled; sidebar_web }
10296
10297 let enabled t = t.enabled
10298 let sidebar_web t = t.sidebar_web
10299
10300 let jsont : t Jsont.t =
10301 Jsont.Object.map ~kind:"FoldersResponse"
10302 (fun enabled sidebar_web -> { enabled; sidebar_web })
10303 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.enabled)
10304 |> Jsont.Object.mem "sidebarWeb" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.sidebar_web)
10305 |> Jsont.Object.skip_unknown
10306 |> Jsont.Object.finish
10307 end
10308end
10309
10310module FacialRecognition = struct
10311 module Types = struct
10312 module Config = struct
10313 type t = {
10314 enabled : bool;
10315 max_distance : float;
10316 min_faces : int;
10317 min_score : float;
10318 model_name : string;
10319 }
10320 end
10321 end
10322
10323 module Config = struct
10324 include Types.Config
10325
10326 let v ~enabled ~max_distance ~min_faces ~min_score ~model_name () = { enabled; max_distance; min_faces; min_score; model_name }
10327
10328 let enabled t = t.enabled
10329 let max_distance t = t.max_distance
10330 let min_faces t = t.min_faces
10331 let min_score t = t.min_score
10332 let model_name t = t.model_name
10333
10334 let jsont : t Jsont.t =
10335 Jsont.Object.map ~kind:"FacialRecognitionConfig"
10336 (fun enabled max_distance min_faces min_score model_name -> { enabled; max_distance; min_faces; min_score; model_name })
10337 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10338 |> Jsont.Object.mem "maxDistance" (Openapi.Runtime.validated_float ~minimum:0.1 ~maximum:2. Jsont.number) ~enc:(fun r -> r.max_distance)
10339 |> Jsont.Object.mem "minFaces" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.min_faces)
10340 |> Jsont.Object.mem "minScore" (Openapi.Runtime.validated_float ~minimum:0.1 ~maximum:1. Jsont.number) ~enc:(fun r -> r.min_score)
10341 |> Jsont.Object.mem "modelName" Jsont.string ~enc:(fun r -> r.model_name)
10342 |> Jsont.Object.skip_unknown
10343 |> Jsont.Object.finish
10344 end
10345end
10346
10347module Face = struct
10348 module Types = struct
10349 module Dto = struct
10350 type t = {
10351 id : string;
10352 }
10353 end
10354 end
10355
10356 module Dto = struct
10357 include Types.Dto
10358
10359 let v ~id () = { id }
10360
10361 let id t = t.id
10362
10363 let jsont : t Jsont.t =
10364 Jsont.Object.map ~kind:"FaceDto"
10365 (fun id -> { id })
10366 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
10367 |> Jsont.Object.skip_unknown
10368 |> Jsont.Object.finish
10369 end
10370end
10371
10372module Exif = struct
10373 module Types = struct
10374 module ResponseDto = struct
10375 type t = {
10376 city : string option;
10377 country : string option;
10378 date_time_original : Ptime.t option;
10379 description : string option;
10380 exif_image_height : float option;
10381 exif_image_width : float option;
10382 exposure_time : string option;
10383 f_number : float option;
10384 file_size_in_byte : int64 option;
10385 focal_length : float option;
10386 iso : float option;
10387 latitude : float option;
10388 lens_model : string option;
10389 longitude : float option;
10390 make : string option;
10391 model : string option;
10392 modify_date : Ptime.t option;
10393 orientation : string option;
10394 projection_type : string option;
10395 rating : float option;
10396 state : string option;
10397 time_zone : string option;
10398 }
10399 end
10400 end
10401
10402 module ResponseDto = struct
10403 include Types.ResponseDto
10404
10405 let v ?(city=None) ?(country=None) ?(date_time_original=None) ?(description=None) ?(exif_image_height=None) ?(exif_image_width=None) ?(exposure_time=None) ?(f_number=None) ?(file_size_in_byte=None) ?(focal_length=None) ?(iso=None) ?(latitude=None) ?(lens_model=None) ?(longitude=None) ?(make=None) ?(model=None) ?(modify_date=None) ?(orientation=None) ?(projection_type=None) ?(rating=None) ?(state=None) ?(time_zone=None) () = { city; country; date_time_original; description; exif_image_height; exif_image_width; exposure_time; f_number; file_size_in_byte; focal_length; iso; latitude; lens_model; longitude; make; model; modify_date; orientation; projection_type; rating; state; time_zone }
10406
10407 let city t = t.city
10408 let country t = t.country
10409 let date_time_original t = t.date_time_original
10410 let description t = t.description
10411 let exif_image_height t = t.exif_image_height
10412 let exif_image_width t = t.exif_image_width
10413 let exposure_time t = t.exposure_time
10414 let f_number t = t.f_number
10415 let file_size_in_byte t = t.file_size_in_byte
10416 let focal_length t = t.focal_length
10417 let iso t = t.iso
10418 let latitude t = t.latitude
10419 let lens_model t = t.lens_model
10420 let longitude t = t.longitude
10421 let make t = t.make
10422 let model t = t.model
10423 let modify_date t = t.modify_date
10424 let orientation t = t.orientation
10425 let projection_type t = t.projection_type
10426 let rating t = t.rating
10427 let state t = t.state
10428 let time_zone t = t.time_zone
10429
10430 let jsont : t Jsont.t =
10431 Jsont.Object.map ~kind:"ExifResponseDto"
10432 (fun city country date_time_original description exif_image_height exif_image_width exposure_time f_number file_size_in_byte focal_length iso latitude lens_model longitude make model modify_date orientation projection_type rating state time_zone -> { city; country; date_time_original; description; exif_image_height; exif_image_width; exposure_time; f_number; file_size_in_byte; focal_length; iso; latitude; lens_model; longitude; make; model; modify_date; orientation; projection_type; rating; state; time_zone })
10433 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
10434 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
10435 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
10436 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
10437 |> Jsont.Object.mem "dateTimeOriginal" Openapi.Runtime.nullable_ptime
10438 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.date_time_original)
10439 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
10440 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
10441 |> Jsont.Object.mem "exifImageHeight" Openapi.Runtime.nullable_float
10442 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exif_image_height)
10443 |> Jsont.Object.mem "exifImageWidth" Openapi.Runtime.nullable_float
10444 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exif_image_width)
10445 |> Jsont.Object.mem "exposureTime" Openapi.Runtime.nullable_string
10446 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.exposure_time)
10447 |> Jsont.Object.mem "fNumber" Openapi.Runtime.nullable_float
10448 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.f_number)
10449 |> Jsont.Object.mem "fileSizeInByte" (Openapi.Runtime.nullable_any Jsont.int64)
10450 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.file_size_in_byte)
10451 |> Jsont.Object.mem "focalLength" Openapi.Runtime.nullable_float
10452 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.focal_length)
10453 |> Jsont.Object.mem "iso" Openapi.Runtime.nullable_float
10454 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.iso)
10455 |> Jsont.Object.mem "latitude" Openapi.Runtime.nullable_float
10456 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.latitude)
10457 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
10458 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
10459 |> Jsont.Object.mem "longitude" Openapi.Runtime.nullable_float
10460 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.longitude)
10461 |> Jsont.Object.mem "make" Openapi.Runtime.nullable_string
10462 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.make)
10463 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
10464 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
10465 |> Jsont.Object.mem "modifyDate" Openapi.Runtime.nullable_ptime
10466 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.modify_date)
10467 |> Jsont.Object.mem "orientation" Openapi.Runtime.nullable_string
10468 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.orientation)
10469 |> Jsont.Object.mem "projectionType" Openapi.Runtime.nullable_string
10470 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.projection_type)
10471 |> Jsont.Object.mem "rating" Openapi.Runtime.nullable_float
10472 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.rating)
10473 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
10474 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
10475 |> Jsont.Object.mem "timeZone" Openapi.Runtime.nullable_string
10476 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.time_zone)
10477 |> Jsont.Object.skip_unknown
10478 |> Jsont.Object.finish
10479 end
10480end
10481
10482module EmailNotifications = struct
10483 module Types = struct
10484 module Update = struct
10485 type t = {
10486 album_invite : bool option;
10487 album_update : bool option;
10488 enabled : bool option;
10489 }
10490 end
10491
10492 module Response = struct
10493 type t = {
10494 album_invite : bool;
10495 album_update : bool;
10496 enabled : bool;
10497 }
10498 end
10499 end
10500
10501 module Update = struct
10502 include Types.Update
10503
10504 let v ?album_invite ?album_update ?enabled () = { album_invite; album_update; enabled }
10505
10506 let album_invite t = t.album_invite
10507 let album_update t = t.album_update
10508 let enabled t = t.enabled
10509
10510 let jsont : t Jsont.t =
10511 Jsont.Object.map ~kind:"EmailNotificationsUpdate"
10512 (fun album_invite album_update enabled -> { album_invite; album_update; enabled })
10513 |> Jsont.Object.opt_mem "albumInvite" Jsont.bool ~enc:(fun r -> r.album_invite)
10514 |> Jsont.Object.opt_mem "albumUpdate" Jsont.bool ~enc:(fun r -> r.album_update)
10515 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10516 |> Jsont.Object.skip_unknown
10517 |> Jsont.Object.finish
10518 end
10519
10520 module Response = struct
10521 include Types.Response
10522
10523 let v ~album_invite ~album_update ~enabled () = { album_invite; album_update; enabled }
10524
10525 let album_invite t = t.album_invite
10526 let album_update t = t.album_update
10527 let enabled t = t.enabled
10528
10529 let jsont : t Jsont.t =
10530 Jsont.Object.map ~kind:"EmailNotificationsResponse"
10531 (fun album_invite album_update enabled -> { album_invite; album_update; enabled })
10532 |> Jsont.Object.mem "albumInvite" Jsont.bool ~enc:(fun r -> r.album_invite)
10533 |> Jsont.Object.mem "albumUpdate" Jsont.bool ~enc:(fun r -> r.album_update)
10534 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10535 |> Jsont.Object.skip_unknown
10536 |> Jsont.Object.finish
10537 end
10538end
10539
10540module DuplicateDetection = struct
10541 module Types = struct
10542 module Config = struct
10543 type t = {
10544 enabled : bool;
10545 max_distance : float;
10546 }
10547 end
10548 end
10549
10550 module Config = struct
10551 include Types.Config
10552
10553 let v ~enabled ~max_distance () = { enabled; max_distance }
10554
10555 let enabled t = t.enabled
10556 let max_distance t = t.max_distance
10557
10558 let jsont : t Jsont.t =
10559 Jsont.Object.map ~kind:"DuplicateDetectionConfig"
10560 (fun enabled max_distance -> { enabled; max_distance })
10561 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10562 |> Jsont.Object.mem "maxDistance" (Openapi.Runtime.validated_float ~minimum:0.001 ~maximum:0.1 Jsont.number) ~enc:(fun r -> r.max_distance)
10563 |> Jsont.Object.skip_unknown
10564 |> Jsont.Object.finish
10565 end
10566end
10567
10568module DownloadInfo = struct
10569 module Types = struct
10570 module Dto = struct
10571 type t = {
10572 album_id : string option;
10573 archive_size : int option;
10574 asset_ids : string list option;
10575 user_id : string option;
10576 }
10577 end
10578 end
10579
10580 module Dto = struct
10581 include Types.Dto
10582
10583 let v ?album_id ?archive_size ?asset_ids ?user_id () = { album_id; archive_size; asset_ids; user_id }
10584
10585 let album_id t = t.album_id
10586 let archive_size t = t.archive_size
10587 let asset_ids t = t.asset_ids
10588 let user_id t = t.user_id
10589
10590 let jsont : t Jsont.t =
10591 Jsont.Object.map ~kind:"DownloadInfoDto"
10592 (fun album_id archive_size asset_ids user_id -> { album_id; archive_size; asset_ids; user_id })
10593 |> Jsont.Object.opt_mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
10594 |> Jsont.Object.opt_mem "archiveSize" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.archive_size)
10595 |> Jsont.Object.opt_mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
10596 |> Jsont.Object.opt_mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
10597 |> Jsont.Object.skip_unknown
10598 |> Jsont.Object.finish
10599 end
10600end
10601
10602module DownloadArchive = struct
10603 module Types = struct
10604 module Info = struct
10605 type t = {
10606 asset_ids : string list;
10607 size : int;
10608 }
10609 end
10610 end
10611
10612 module Info = struct
10613 include Types.Info
10614
10615 let v ~asset_ids ~size () = { asset_ids; size }
10616
10617 let asset_ids t = t.asset_ids
10618 let size t = t.size
10619
10620 let jsont : t Jsont.t =
10621 Jsont.Object.map ~kind:"DownloadArchiveInfo"
10622 (fun asset_ids size -> { asset_ids; size })
10623 |> Jsont.Object.mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
10624 |> Jsont.Object.mem "size" Jsont.int ~enc:(fun r -> r.size)
10625 |> Jsont.Object.skip_unknown
10626 |> Jsont.Object.finish
10627 end
10628end
10629
10630module Download = struct
10631 module Types = struct
10632 module Update = struct
10633 type t = {
10634 archive_size : int option;
10635 include_embedded_videos : bool option;
10636 }
10637 end
10638
10639 module ResponseDto = struct
10640 type t = {
10641 archives : DownloadArchive.Info.t list;
10642 total_size : int;
10643 }
10644 end
10645
10646 module Response = struct
10647 type t = {
10648 archive_size : int;
10649 include_embedded_videos : bool;
10650 }
10651 end
10652 end
10653
10654 module Update = struct
10655 include Types.Update
10656
10657 let v ?archive_size ?include_embedded_videos () = { archive_size; include_embedded_videos }
10658
10659 let archive_size t = t.archive_size
10660 let include_embedded_videos t = t.include_embedded_videos
10661
10662 let jsont : t Jsont.t =
10663 Jsont.Object.map ~kind:"DownloadUpdate"
10664 (fun archive_size include_embedded_videos -> { archive_size; include_embedded_videos })
10665 |> Jsont.Object.opt_mem "archiveSize" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.archive_size)
10666 |> Jsont.Object.opt_mem "includeEmbeddedVideos" Jsont.bool ~enc:(fun r -> r.include_embedded_videos)
10667 |> Jsont.Object.skip_unknown
10668 |> Jsont.Object.finish
10669 end
10670
10671 module ResponseDto = struct
10672 include Types.ResponseDto
10673
10674 let v ~archives ~total_size () = { archives; total_size }
10675
10676 let archives t = t.archives
10677 let total_size t = t.total_size
10678
10679 let jsont : t Jsont.t =
10680 Jsont.Object.map ~kind:"DownloadResponseDto"
10681 (fun archives total_size -> { archives; total_size })
10682 |> Jsont.Object.mem "archives" (Jsont.list DownloadArchive.Info.jsont) ~enc:(fun r -> r.archives)
10683 |> Jsont.Object.mem "totalSize" Jsont.int ~enc:(fun r -> r.total_size)
10684 |> Jsont.Object.skip_unknown
10685 |> Jsont.Object.finish
10686 end
10687
10688 module Response = struct
10689 include Types.Response
10690
10691 let v ~archive_size ?(include_embedded_videos=false) () = { archive_size; include_embedded_videos }
10692
10693 let archive_size t = t.archive_size
10694 let include_embedded_videos t = t.include_embedded_videos
10695
10696 let jsont : t Jsont.t =
10697 Jsont.Object.map ~kind:"DownloadResponse"
10698 (fun archive_size include_embedded_videos -> { archive_size; include_embedded_videos })
10699 |> Jsont.Object.mem "archiveSize" Jsont.int ~enc:(fun r -> r.archive_size)
10700 |> Jsont.Object.mem "includeEmbeddedVideos" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.include_embedded_videos)
10701 |> Jsont.Object.skip_unknown
10702 |> Jsont.Object.finish
10703 end
10704
10705 (** Retrieve download information
10706
10707 Retrieve information about how to request a download for the specified assets or album. The response includes groups of assets that can be downloaded together. *)
10708 let get_download_info ?key ?slug ~body client () =
10709 let op_name = "get_download_info" in
10710 let url_path = "/download/info" in
10711 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
10712 let url = client.base_url ^ url_path ^ query in
10713 let response =
10714 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json DownloadInfo.Dto.jsont body)) url
10715 with Eio.Io _ as ex ->
10716 let bt = Printexc.get_raw_backtrace () in
10717 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
10718 in
10719 if Requests.Response.ok response then
10720 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
10721 else
10722 let body = Requests.Response.text response in
10723 let parsed_body =
10724 match Jsont_bytesrw.decode_string Jsont.json body with
10725 | Ok json -> Some (Openapi.Runtime.Json json)
10726 | Error _ -> Some (Openapi.Runtime.Raw body)
10727 in
10728 raise (Openapi.Runtime.Api_error {
10729 operation = op_name;
10730 method_ = "POST";
10731 url;
10732 status = Requests.Response.status_code response;
10733 body;
10734 parsed_body;
10735 })
10736end
10737
10738module DatabaseBackupUpload = struct
10739 module Types = struct
10740 module Dto = struct
10741 type t = {
10742 file : string option;
10743 }
10744 end
10745 end
10746
10747 module Dto = struct
10748 include Types.Dto
10749
10750 let v ?file () = { file }
10751
10752 let file t = t.file
10753
10754 let jsont : t Jsont.t =
10755 Jsont.Object.map ~kind:"DatabaseBackupUploadDto"
10756 (fun file -> { file })
10757 |> Jsont.Object.opt_mem "file" Jsont.string ~enc:(fun r -> r.file)
10758 |> Jsont.Object.skip_unknown
10759 |> Jsont.Object.finish
10760 end
10761end
10762
10763module DatabaseBackupDelete = struct
10764 module Types = struct
10765 module Dto = struct
10766 type t = {
10767 backups : string list;
10768 }
10769 end
10770 end
10771
10772 module Dto = struct
10773 include Types.Dto
10774
10775 let v ~backups () = { backups }
10776
10777 let backups t = t.backups
10778
10779 let jsont : t Jsont.t =
10780 Jsont.Object.map ~kind:"DatabaseBackupDeleteDto"
10781 (fun backups -> { backups })
10782 |> Jsont.Object.mem "backups" (Jsont.list Jsont.string) ~enc:(fun r -> r.backups)
10783 |> Jsont.Object.skip_unknown
10784 |> Jsont.Object.finish
10785 end
10786end
10787
10788module DatabaseBackup = struct
10789 module Types = struct
10790 module Dto = struct
10791 type t = {
10792 filename : string;
10793 filesize : float;
10794 }
10795 end
10796
10797 module Config = struct
10798 type t = {
10799 cron_expression : string;
10800 enabled : bool;
10801 keep_last_amount : float;
10802 }
10803 end
10804 end
10805
10806 module Dto = struct
10807 include Types.Dto
10808
10809 let v ~filename ~filesize () = { filename; filesize }
10810
10811 let filename t = t.filename
10812 let filesize t = t.filesize
10813
10814 let jsont : t Jsont.t =
10815 Jsont.Object.map ~kind:"DatabaseBackupDto"
10816 (fun filename filesize -> { filename; filesize })
10817 |> Jsont.Object.mem "filename" Jsont.string ~enc:(fun r -> r.filename)
10818 |> Jsont.Object.mem "filesize" Jsont.number ~enc:(fun r -> r.filesize)
10819 |> Jsont.Object.skip_unknown
10820 |> Jsont.Object.finish
10821 end
10822
10823 module Config = struct
10824 include Types.Config
10825
10826 let v ~cron_expression ~enabled ~keep_last_amount () = { cron_expression; enabled; keep_last_amount }
10827
10828 let cron_expression t = t.cron_expression
10829 let enabled t = t.enabled
10830 let keep_last_amount t = t.keep_last_amount
10831
10832 let jsont : t Jsont.t =
10833 Jsont.Object.map ~kind:"DatabaseBackupConfig"
10834 (fun cron_expression enabled keep_last_amount -> { cron_expression; enabled; keep_last_amount })
10835 |> Jsont.Object.mem "cronExpression" Jsont.string ~enc:(fun r -> r.cron_expression)
10836 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
10837 |> Jsont.Object.mem "keepLastAmount" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.keep_last_amount)
10838 |> Jsont.Object.skip_unknown
10839 |> Jsont.Object.finish
10840 end
10841end
10842
10843module SystemConfigBackups = struct
10844 module Types = struct
10845 module Dto = struct
10846 type t = {
10847 database : DatabaseBackup.Config.t;
10848 }
10849 end
10850 end
10851
10852 module Dto = struct
10853 include Types.Dto
10854
10855 let v ~database () = { database }
10856
10857 let database t = t.database
10858
10859 let jsont : t Jsont.t =
10860 Jsont.Object.map ~kind:"SystemConfigBackupsDto"
10861 (fun database -> { database })
10862 |> Jsont.Object.mem "database" DatabaseBackup.Config.jsont ~enc:(fun r -> r.database)
10863 |> Jsont.Object.skip_unknown
10864 |> Jsont.Object.finish
10865 end
10866end
10867
10868module DatabaseBackupList = struct
10869 module Types = struct
10870 module ResponseDto = struct
10871 type t = {
10872 backups : DatabaseBackup.Dto.t list;
10873 }
10874 end
10875 end
10876
10877 module ResponseDto = struct
10878 include Types.ResponseDto
10879
10880 let v ~backups () = { backups }
10881
10882 let backups t = t.backups
10883
10884 let jsont : t Jsont.t =
10885 Jsont.Object.map ~kind:"DatabaseBackupListResponseDto"
10886 (fun backups -> { backups })
10887 |> Jsont.Object.mem "backups" (Jsont.list DatabaseBackup.Dto.jsont) ~enc:(fun r -> r.backups)
10888 |> Jsont.Object.skip_unknown
10889 |> Jsont.Object.finish
10890 end
10891
10892 (** List database backups
10893
10894 Get the list of the successful and failed backups *)
10895 let list_database_backups client () =
10896 let op_name = "list_database_backups" in
10897 let url_path = "/admin/database-backups" in
10898 let query = "" in
10899 let url = client.base_url ^ url_path ^ query in
10900 let response =
10901 try Requests.get client.session url
10902 with Eio.Io _ as ex ->
10903 let bt = Printexc.get_raw_backtrace () in
10904 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
10905 in
10906 if Requests.Response.ok response then
10907 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
10908 else
10909 let body = Requests.Response.text response in
10910 let parsed_body =
10911 match Jsont_bytesrw.decode_string Jsont.json body with
10912 | Ok json -> Some (Openapi.Runtime.Json json)
10913 | Error _ -> Some (Openapi.Runtime.Raw body)
10914 in
10915 raise (Openapi.Runtime.Api_error {
10916 operation = op_name;
10917 method_ = "GET";
10918 url;
10919 status = Requests.Response.status_code response;
10920 body;
10921 parsed_body;
10922 })
10923end
10924
10925module CropParameters = struct
10926 module Types = struct
10927 module T = struct
10928 type t = {
10929 height : float; (** Height of the crop *)
10930 width : float; (** Width of the crop *)
10931 x : float; (** Top-Left X coordinate of crop *)
10932 y : float; (** Top-Left Y coordinate of crop *)
10933 }
10934 end
10935 end
10936
10937 module T = struct
10938 include Types.T
10939
10940 let v ~height ~width ~x ~y () = { height; width; x; y }
10941
10942 let height t = t.height
10943 let width t = t.width
10944 let x t = t.x
10945 let y t = t.y
10946
10947 let jsont : t Jsont.t =
10948 Jsont.Object.map ~kind:"CropParameters"
10949 (fun height width x y -> { height; width; x; y })
10950 |> Jsont.Object.mem "height" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.height)
10951 |> Jsont.Object.mem "width" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.width)
10952 |> Jsont.Object.mem "x" (Openapi.Runtime.validated_float ~minimum:0. Jsont.number) ~enc:(fun r -> r.x)
10953 |> Jsont.Object.mem "y" (Openapi.Runtime.validated_float ~minimum:0. Jsont.number) ~enc:(fun r -> r.y)
10954 |> Jsont.Object.skip_unknown
10955 |> Jsont.Object.finish
10956 end
10957end
10958
10959module CreateProfileImage = struct
10960 module Types = struct
10961 module ResponseDto = struct
10962 type t = {
10963 profile_changed_at : Ptime.t;
10964 profile_image_path : string;
10965 user_id : string;
10966 }
10967 end
10968
10969 module Dto = struct
10970 type t = {
10971 file : string;
10972 }
10973 end
10974 end
10975
10976 module ResponseDto = struct
10977 include Types.ResponseDto
10978
10979 let v ~profile_changed_at ~profile_image_path ~user_id () = { profile_changed_at; profile_image_path; user_id }
10980
10981 let profile_changed_at t = t.profile_changed_at
10982 let profile_image_path t = t.profile_image_path
10983 let user_id t = t.user_id
10984
10985 let jsont : t Jsont.t =
10986 Jsont.Object.map ~kind:"CreateProfileImageResponseDto"
10987 (fun profile_changed_at profile_image_path user_id -> { profile_changed_at; profile_image_path; user_id })
10988 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
10989 |> Jsont.Object.mem "profileImagePath" Jsont.string ~enc:(fun r -> r.profile_image_path)
10990 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
10991 |> Jsont.Object.skip_unknown
10992 |> Jsont.Object.finish
10993 end
10994
10995 module Dto = struct
10996 include Types.Dto
10997
10998 let v ~file () = { file }
10999
11000 let file t = t.file
11001
11002 let jsont : t Jsont.t =
11003 Jsont.Object.map ~kind:"CreateProfileImageDto"
11004 (fun file -> { file })
11005 |> Jsont.Object.mem "file" Jsont.string ~enc:(fun r -> r.file)
11006 |> Jsont.Object.skip_unknown
11007 |> Jsont.Object.finish
11008 end
11009
11010 (** Create user profile image
11011
11012 Upload and set a new profile image for the current user. *)
11013 let create_profile_image client () =
11014 let op_name = "create_profile_image" in
11015 let url_path = "/users/profile-image" in
11016 let query = "" in
11017 let url = client.base_url ^ url_path ^ query in
11018 let response =
11019 try Requests.post client.session url
11020 with Eio.Io _ as ex ->
11021 let bt = Printexc.get_raw_backtrace () in
11022 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11023 in
11024 if Requests.Response.ok response then
11025 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11026 else
11027 let body = Requests.Response.text response in
11028 let parsed_body =
11029 match Jsont_bytesrw.decode_string Jsont.json body with
11030 | Ok json -> Some (Openapi.Runtime.Json json)
11031 | Error _ -> Some (Openapi.Runtime.Raw body)
11032 in
11033 raise (Openapi.Runtime.Api_error {
11034 operation = op_name;
11035 method_ = "POST";
11036 url;
11037 status = Requests.Response.status_code response;
11038 body;
11039 parsed_body;
11040 })
11041end
11042
11043module CreateLibrary = struct
11044 module Types = struct
11045 module Dto = struct
11046 type t = {
11047 exclusion_patterns : string list option;
11048 import_paths : string list option;
11049 name : string option;
11050 owner_id : string;
11051 }
11052 end
11053 end
11054
11055 module Dto = struct
11056 include Types.Dto
11057
11058 let v ~owner_id ?exclusion_patterns ?import_paths ?name () = { exclusion_patterns; import_paths; name; owner_id }
11059
11060 let exclusion_patterns t = t.exclusion_patterns
11061 let import_paths t = t.import_paths
11062 let name t = t.name
11063 let owner_id t = t.owner_id
11064
11065 let jsont : t Jsont.t =
11066 Jsont.Object.map ~kind:"CreateLibraryDto"
11067 (fun exclusion_patterns import_paths name owner_id -> { exclusion_patterns; import_paths; name; owner_id })
11068 |> Jsont.Object.opt_mem "exclusionPatterns" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.exclusion_patterns)
11069 |> Jsont.Object.opt_mem "importPaths" (Openapi.Runtime.validated_list ~max_items:128 ~unique_items:true Jsont.string) ~enc:(fun r -> r.import_paths)
11070 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
11071 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
11072 |> Jsont.Object.skip_unknown
11073 |> Jsont.Object.finish
11074 end
11075end
11076
11077module Library = struct
11078 module Types = struct
11079 module ResponseDto = struct
11080 type t = {
11081 asset_count : int;
11082 created_at : Ptime.t;
11083 exclusion_patterns : string list;
11084 id : string;
11085 import_paths : string list;
11086 name : string;
11087 owner_id : string;
11088 refreshed_at : Ptime.t option;
11089 updated_at : Ptime.t;
11090 }
11091 end
11092 end
11093
11094 module ResponseDto = struct
11095 include Types.ResponseDto
11096
11097 let v ~asset_count ~created_at ~exclusion_patterns ~id ~import_paths ~name ~owner_id ~updated_at ?refreshed_at () = { asset_count; created_at; exclusion_patterns; id; import_paths; name; owner_id; refreshed_at; updated_at }
11098
11099 let asset_count t = t.asset_count
11100 let created_at t = t.created_at
11101 let exclusion_patterns t = t.exclusion_patterns
11102 let id t = t.id
11103 let import_paths t = t.import_paths
11104 let name t = t.name
11105 let owner_id t = t.owner_id
11106 let refreshed_at t = t.refreshed_at
11107 let updated_at t = t.updated_at
11108
11109 let jsont : t Jsont.t =
11110 Jsont.Object.map ~kind:"LibraryResponseDto"
11111 (fun asset_count created_at exclusion_patterns id import_paths name owner_id refreshed_at updated_at -> { asset_count; created_at; exclusion_patterns; id; import_paths; name; owner_id; refreshed_at; updated_at })
11112 |> Jsont.Object.mem "assetCount" Jsont.int ~enc:(fun r -> r.asset_count)
11113 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
11114 |> Jsont.Object.mem "exclusionPatterns" (Jsont.list Jsont.string) ~enc:(fun r -> r.exclusion_patterns)
11115 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
11116 |> Jsont.Object.mem "importPaths" (Jsont.list Jsont.string) ~enc:(fun r -> r.import_paths)
11117 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
11118 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
11119 |> Jsont.Object.mem "refreshedAt" Openapi.Runtime.nullable_ptime
11120 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.refreshed_at)
11121 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
11122 |> Jsont.Object.skip_unknown
11123 |> Jsont.Object.finish
11124 end
11125
11126 (** Retrieve libraries
11127
11128 Retrieve a list of external libraries. *)
11129 let get_all_libraries client () =
11130 let op_name = "get_all_libraries" in
11131 let url_path = "/libraries" in
11132 let query = "" in
11133 let url = client.base_url ^ url_path ^ query in
11134 let response =
11135 try Requests.get client.session url
11136 with Eio.Io _ as ex ->
11137 let bt = Printexc.get_raw_backtrace () in
11138 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
11139 in
11140 if Requests.Response.ok response then
11141 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11142 else
11143 let body = Requests.Response.text response in
11144 let parsed_body =
11145 match Jsont_bytesrw.decode_string Jsont.json body with
11146 | Ok json -> Some (Openapi.Runtime.Json json)
11147 | Error _ -> Some (Openapi.Runtime.Raw body)
11148 in
11149 raise (Openapi.Runtime.Api_error {
11150 operation = op_name;
11151 method_ = "GET";
11152 url;
11153 status = Requests.Response.status_code response;
11154 body;
11155 parsed_body;
11156 })
11157
11158 (** Create a library
11159
11160 Create a new external library. *)
11161 let create_library ~body client () =
11162 let op_name = "create_library" in
11163 let url_path = "/libraries" in
11164 let query = "" in
11165 let url = client.base_url ^ url_path ^ query in
11166 let response =
11167 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateLibrary.Dto.jsont body)) url
11168 with Eio.Io _ as ex ->
11169 let bt = Printexc.get_raw_backtrace () in
11170 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11171 in
11172 if Requests.Response.ok response then
11173 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11174 else
11175 let body = Requests.Response.text response in
11176 let parsed_body =
11177 match Jsont_bytesrw.decode_string Jsont.json body with
11178 | Ok json -> Some (Openapi.Runtime.Json json)
11179 | Error _ -> Some (Openapi.Runtime.Raw body)
11180 in
11181 raise (Openapi.Runtime.Api_error {
11182 operation = op_name;
11183 method_ = "POST";
11184 url;
11185 status = Requests.Response.status_code response;
11186 body;
11187 parsed_body;
11188 })
11189
11190 (** Retrieve a library
11191
11192 Retrieve an external library by its ID. *)
11193 let get_library ~id client () =
11194 let op_name = "get_library" in
11195 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}" in
11196 let query = "" in
11197 let url = client.base_url ^ url_path ^ query in
11198 let response =
11199 try Requests.get client.session url
11200 with Eio.Io _ as ex ->
11201 let bt = Printexc.get_raw_backtrace () in
11202 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
11203 in
11204 if Requests.Response.ok response then
11205 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11206 else
11207 let body = Requests.Response.text response in
11208 let parsed_body =
11209 match Jsont_bytesrw.decode_string Jsont.json body with
11210 | Ok json -> Some (Openapi.Runtime.Json json)
11211 | Error _ -> Some (Openapi.Runtime.Raw body)
11212 in
11213 raise (Openapi.Runtime.Api_error {
11214 operation = op_name;
11215 method_ = "GET";
11216 url;
11217 status = Requests.Response.status_code response;
11218 body;
11219 parsed_body;
11220 })
11221
11222 (** Update a library
11223
11224 Update an existing external library. *)
11225 let update_library ~id ~body client () =
11226 let op_name = "update_library" in
11227 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}" in
11228 let query = "" in
11229 let url = client.base_url ^ url_path ^ query in
11230 let response =
11231 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateLibrary.Dto.jsont body)) url
11232 with Eio.Io _ as ex ->
11233 let bt = Printexc.get_raw_backtrace () in
11234 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
11235 in
11236 if Requests.Response.ok response then
11237 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11238 else
11239 let body = Requests.Response.text response in
11240 let parsed_body =
11241 match Jsont_bytesrw.decode_string Jsont.json body with
11242 | Ok json -> Some (Openapi.Runtime.Json json)
11243 | Error _ -> Some (Openapi.Runtime.Raw body)
11244 in
11245 raise (Openapi.Runtime.Api_error {
11246 operation = op_name;
11247 method_ = "PUT";
11248 url;
11249 status = Requests.Response.status_code response;
11250 body;
11251 parsed_body;
11252 })
11253end
11254
11255module Cqmode = struct
11256 module Types = struct
11257 module T = struct
11258 type t = [
11259 | `Auto
11260 | `Cqp
11261 | `Icq
11262 ]
11263 end
11264 end
11265
11266 module T = struct
11267 include Types.T
11268
11269 let jsont : t Jsont.t =
11270 Jsont.map Jsont.string ~kind:"CQMode"
11271 ~dec:(function
11272 | "auto" -> `Auto
11273 | "cqp" -> `Cqp
11274 | "icq" -> `Icq
11275 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
11276 ~enc:(function
11277 | `Auto -> "auto"
11278 | `Cqp -> "cqp"
11279 | `Icq -> "icq")
11280 end
11281end
11282
11283module ContributorCount = struct
11284 module Types = struct
11285 module ResponseDto = struct
11286 type t = {
11287 asset_count : int;
11288 user_id : string;
11289 }
11290 end
11291 end
11292
11293 module ResponseDto = struct
11294 include Types.ResponseDto
11295
11296 let v ~asset_count ~user_id () = { asset_count; user_id }
11297
11298 let asset_count t = t.asset_count
11299 let user_id t = t.user_id
11300
11301 let jsont : t Jsont.t =
11302 Jsont.Object.map ~kind:"ContributorCountResponseDto"
11303 (fun asset_count user_id -> { asset_count; user_id })
11304 |> Jsont.Object.mem "assetCount" Jsont.int ~enc:(fun r -> r.asset_count)
11305 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
11306 |> Jsont.Object.skip_unknown
11307 |> Jsont.Object.finish
11308 end
11309end
11310
11311module Colorspace = struct
11312 module Types = struct
11313 module T = struct
11314 type t = [
11315 | `Srgb
11316 | `P3
11317 ]
11318 end
11319 end
11320
11321 module T = struct
11322 include Types.T
11323
11324 let jsont : t Jsont.t =
11325 Jsont.map Jsont.string ~kind:"Colorspace"
11326 ~dec:(function
11327 | "srgb" -> `Srgb
11328 | "p3" -> `P3
11329 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
11330 ~enc:(function
11331 | `Srgb -> "srgb"
11332 | `P3 -> "p3")
11333 end
11334end
11335
11336module SystemConfigImage = struct
11337 module Types = struct
11338 module Dto = struct
11339 type t = {
11340 colorspace : Colorspace.T.t;
11341 extract_embedded : bool;
11342 fullsize : SystemConfigGeneratedFullsizeImage.Dto.t;
11343 preview : SystemConfigGeneratedImage.Dto.t;
11344 thumbnail : SystemConfigGeneratedImage.Dto.t;
11345 }
11346 end
11347 end
11348
11349 module Dto = struct
11350 include Types.Dto
11351
11352 let v ~colorspace ~extract_embedded ~fullsize ~preview ~thumbnail () = { colorspace; extract_embedded; fullsize; preview; thumbnail }
11353
11354 let colorspace t = t.colorspace
11355 let extract_embedded t = t.extract_embedded
11356 let fullsize t = t.fullsize
11357 let preview t = t.preview
11358 let thumbnail t = t.thumbnail
11359
11360 let jsont : t Jsont.t =
11361 Jsont.Object.map ~kind:"SystemConfigImageDto"
11362 (fun colorspace extract_embedded fullsize preview thumbnail -> { colorspace; extract_embedded; fullsize; preview; thumbnail })
11363 |> Jsont.Object.mem "colorspace" Colorspace.T.jsont ~enc:(fun r -> r.colorspace)
11364 |> Jsont.Object.mem "extractEmbedded" Jsont.bool ~enc:(fun r -> r.extract_embedded)
11365 |> Jsont.Object.mem "fullsize" SystemConfigGeneratedFullsizeImage.Dto.jsont ~enc:(fun r -> r.fullsize)
11366 |> Jsont.Object.mem "preview" SystemConfigGeneratedImage.Dto.jsont ~enc:(fun r -> r.preview)
11367 |> Jsont.Object.mem "thumbnail" SystemConfigGeneratedImage.Dto.jsont ~enc:(fun r -> r.thumbnail)
11368 |> Jsont.Object.skip_unknown
11369 |> Jsont.Object.finish
11370 end
11371end
11372
11373module Clip = struct
11374 module Types = struct
11375 module Config = struct
11376 type t = {
11377 enabled : bool;
11378 model_name : string;
11379 }
11380 end
11381 end
11382
11383 module Config = struct
11384 include Types.Config
11385
11386 let v ~enabled ~model_name () = { enabled; model_name }
11387
11388 let enabled t = t.enabled
11389 let model_name t = t.model_name
11390
11391 let jsont : t Jsont.t =
11392 Jsont.Object.map ~kind:"CLIPConfig"
11393 (fun enabled model_name -> { enabled; model_name })
11394 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
11395 |> Jsont.Object.mem "modelName" Jsont.string ~enc:(fun r -> r.model_name)
11396 |> Jsont.Object.skip_unknown
11397 |> Jsont.Object.finish
11398 end
11399end
11400
11401module SystemConfigMachineLearning = struct
11402 module Types = struct
11403 module Dto = struct
11404 type t = {
11405 availability_checks : MachineLearningAvailabilityChecks.Dto.t;
11406 clip : Clip.Config.t;
11407 duplicate_detection : DuplicateDetection.Config.t;
11408 enabled : bool;
11409 facial_recognition : FacialRecognition.Config.t;
11410 ocr : Ocr.Config.t;
11411 urls : string list;
11412 }
11413 end
11414 end
11415
11416 module Dto = struct
11417 include Types.Dto
11418
11419 let v ~availability_checks ~clip ~duplicate_detection ~enabled ~facial_recognition ~ocr ~urls () = { availability_checks; clip; duplicate_detection; enabled; facial_recognition; ocr; urls }
11420
11421 let availability_checks t = t.availability_checks
11422 let clip t = t.clip
11423 let duplicate_detection t = t.duplicate_detection
11424 let enabled t = t.enabled
11425 let facial_recognition t = t.facial_recognition
11426 let ocr t = t.ocr
11427 let urls t = t.urls
11428
11429 let jsont : t Jsont.t =
11430 Jsont.Object.map ~kind:"SystemConfigMachineLearningDto"
11431 (fun availability_checks clip duplicate_detection enabled facial_recognition ocr urls -> { availability_checks; clip; duplicate_detection; enabled; facial_recognition; ocr; urls })
11432 |> Jsont.Object.mem "availabilityChecks" MachineLearningAvailabilityChecks.Dto.jsont ~enc:(fun r -> r.availability_checks)
11433 |> Jsont.Object.mem "clip" Clip.Config.jsont ~enc:(fun r -> r.clip)
11434 |> Jsont.Object.mem "duplicateDetection" DuplicateDetection.Config.jsont ~enc:(fun r -> r.duplicate_detection)
11435 |> Jsont.Object.mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
11436 |> Jsont.Object.mem "facialRecognition" FacialRecognition.Config.jsont ~enc:(fun r -> r.facial_recognition)
11437 |> Jsont.Object.mem "ocr" Ocr.Config.jsont ~enc:(fun r -> r.ocr)
11438 |> Jsont.Object.mem "urls" (Openapi.Runtime.validated_list ~min_items:1 Jsont.string) ~enc:(fun r -> r.urls)
11439 |> Jsont.Object.skip_unknown
11440 |> Jsont.Object.finish
11441 end
11442end
11443
11444module CheckExistingAssets = struct
11445 module Types = struct
11446 module ResponseDto = struct
11447 type t = {
11448 existing_ids : string list;
11449 }
11450 end
11451
11452 module Dto = struct
11453 type t = {
11454 device_asset_ids : string list;
11455 device_id : string;
11456 }
11457 end
11458 end
11459
11460 module ResponseDto = struct
11461 include Types.ResponseDto
11462
11463 let v ~existing_ids () = { existing_ids }
11464
11465 let existing_ids t = t.existing_ids
11466
11467 let jsont : t Jsont.t =
11468 Jsont.Object.map ~kind:"CheckExistingAssetsResponseDto"
11469 (fun existing_ids -> { existing_ids })
11470 |> Jsont.Object.mem "existingIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.existing_ids)
11471 |> Jsont.Object.skip_unknown
11472 |> Jsont.Object.finish
11473 end
11474
11475 module Dto = struct
11476 include Types.Dto
11477
11478 let v ~device_asset_ids ~device_id () = { device_asset_ids; device_id }
11479
11480 let device_asset_ids t = t.device_asset_ids
11481 let device_id t = t.device_id
11482
11483 let jsont : t Jsont.t =
11484 Jsont.Object.map ~kind:"CheckExistingAssetsDto"
11485 (fun device_asset_ids device_id -> { device_asset_ids; device_id })
11486 |> Jsont.Object.mem "deviceAssetIds" (Openapi.Runtime.validated_list ~min_items:1 Jsont.string) ~enc:(fun r -> r.device_asset_ids)
11487 |> Jsont.Object.mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
11488 |> Jsont.Object.skip_unknown
11489 |> Jsont.Object.finish
11490 end
11491
11492 (** Check existing assets
11493
11494 Checks if multiple assets exist on the server and returns all existing - used by background backup *)
11495 let check_existing_assets ~body client () =
11496 let op_name = "check_existing_assets" in
11497 let url_path = "/assets/exist" in
11498 let query = "" in
11499 let url = client.base_url ^ url_path ^ query in
11500 let response =
11501 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
11502 with Eio.Io _ as ex ->
11503 let bt = Printexc.get_raw_backtrace () in
11504 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11505 in
11506 if Requests.Response.ok response then
11507 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11508 else
11509 let body = Requests.Response.text response in
11510 let parsed_body =
11511 match Jsont_bytesrw.decode_string Jsont.json body with
11512 | Ok json -> Some (Openapi.Runtime.Json json)
11513 | Error _ -> Some (Openapi.Runtime.Raw body)
11514 in
11515 raise (Openapi.Runtime.Api_error {
11516 operation = op_name;
11517 method_ = "POST";
11518 url;
11519 status = Requests.Response.status_code response;
11520 body;
11521 parsed_body;
11522 })
11523end
11524
11525module ChangePassword = struct
11526 module Types = struct
11527 module Dto = struct
11528 type t = {
11529 invalidate_sessions : bool;
11530 new_password : string;
11531 password : string;
11532 }
11533 end
11534 end
11535
11536 module Dto = struct
11537 include Types.Dto
11538
11539 let v ~new_password ~password ?(invalidate_sessions=false) () = { invalidate_sessions; new_password; password }
11540
11541 let invalidate_sessions t = t.invalidate_sessions
11542 let new_password t = t.new_password
11543 let password t = t.password
11544
11545 let jsont : t Jsont.t =
11546 Jsont.Object.map ~kind:"ChangePasswordDto"
11547 (fun invalidate_sessions new_password password -> { invalidate_sessions; new_password; password })
11548 |> Jsont.Object.mem "invalidateSessions" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.invalidate_sessions)
11549 |> Jsont.Object.mem "newPassword" (Openapi.Runtime.validated_string ~min_length:8 Jsont.string) ~enc:(fun r -> r.new_password)
11550 |> Jsont.Object.mem "password" Jsont.string ~enc:(fun r -> r.password)
11551 |> Jsont.Object.skip_unknown
11552 |> Jsont.Object.finish
11553 end
11554end
11555
11556module UserAdmin = struct
11557 module Types = struct
11558 module UpdateDto = struct
11559 type t = {
11560 avatar_color : UserAvatarColor.T.t option;
11561 email : string option;
11562 is_admin : bool option;
11563 name : string option;
11564 password : string option;
11565 pin_code : string option;
11566 quota_size_in_bytes : int64 option;
11567 should_change_password : bool option;
11568 storage_label : string option;
11569 }
11570 end
11571
11572 module ResponseDto = struct
11573 type t = {
11574 avatar_color : UserAvatarColor.T.t;
11575 created_at : Ptime.t;
11576 deleted_at : Ptime.t option;
11577 email : string;
11578 id : string;
11579 is_admin : bool;
11580 license : UserLicense.T.t;
11581 name : string;
11582 oauth_id : string;
11583 profile_changed_at : Ptime.t;
11584 profile_image_path : string;
11585 quota_size_in_bytes : int64 option;
11586 quota_usage_in_bytes : int64 option;
11587 should_change_password : bool;
11588 status : User.Status.t;
11589 storage_label : string option;
11590 updated_at : Ptime.t;
11591 }
11592 end
11593
11594 module CreateDto = struct
11595 type t = {
11596 avatar_color : UserAvatarColor.T.t option;
11597 email : string;
11598 is_admin : bool option;
11599 name : string;
11600 notify : bool option;
11601 password : string;
11602 quota_size_in_bytes : int64 option;
11603 should_change_password : bool option;
11604 storage_label : string option;
11605 }
11606 end
11607 end
11608
11609 module UpdateDto = struct
11610 include Types.UpdateDto
11611
11612 let v ?avatar_color ?email ?is_admin ?name ?password ?pin_code ?quota_size_in_bytes ?should_change_password ?storage_label () = { avatar_color; email; is_admin; name; password; pin_code; quota_size_in_bytes; should_change_password; storage_label }
11613
11614 let avatar_color t = t.avatar_color
11615 let email t = t.email
11616 let is_admin t = t.is_admin
11617 let name t = t.name
11618 let password t = t.password
11619 let pin_code t = t.pin_code
11620 let quota_size_in_bytes t = t.quota_size_in_bytes
11621 let should_change_password t = t.should_change_password
11622 let storage_label t = t.storage_label
11623
11624 let jsont : t Jsont.t =
11625 Jsont.Object.map ~kind:"UserAdminUpdateDto"
11626 (fun avatar_color email is_admin name password pin_code quota_size_in_bytes should_change_password storage_label -> { avatar_color; email; is_admin; name; password; pin_code; quota_size_in_bytes; should_change_password; storage_label })
11627 |> Jsont.Object.opt_mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
11628 |> Jsont.Object.opt_mem "email" Jsont.string ~enc:(fun r -> r.email)
11629 |> Jsont.Object.opt_mem "isAdmin" Jsont.bool ~enc:(fun r -> r.is_admin)
11630 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
11631 |> Jsont.Object.opt_mem "password" Jsont.string ~enc:(fun r -> r.password)
11632 |> Jsont.Object.mem "pinCode" Openapi.Runtime.nullable_string
11633 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.pin_code)
11634 |> Jsont.Object.mem "quotaSizeInBytes" (Openapi.Runtime.nullable_any Jsont.int64)
11635 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_size_in_bytes)
11636 |> Jsont.Object.opt_mem "shouldChangePassword" Jsont.bool ~enc:(fun r -> r.should_change_password)
11637 |> Jsont.Object.mem "storageLabel" Openapi.Runtime.nullable_string
11638 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.storage_label)
11639 |> Jsont.Object.skip_unknown
11640 |> Jsont.Object.finish
11641 end
11642
11643 module ResponseDto = struct
11644 include Types.ResponseDto
11645
11646 let v ~avatar_color ~created_at ~email ~id ~is_admin ~license ~name ~oauth_id ~profile_changed_at ~profile_image_path ~should_change_password ~status ~updated_at ?deleted_at ?quota_size_in_bytes ?quota_usage_in_bytes ?storage_label () = { avatar_color; created_at; deleted_at; email; id; is_admin; license; name; oauth_id; profile_changed_at; profile_image_path; quota_size_in_bytes; quota_usage_in_bytes; should_change_password; status; storage_label; updated_at }
11647
11648 let avatar_color t = t.avatar_color
11649 let created_at t = t.created_at
11650 let deleted_at t = t.deleted_at
11651 let email t = t.email
11652 let id t = t.id
11653 let is_admin t = t.is_admin
11654 let license t = t.license
11655 let name t = t.name
11656 let oauth_id t = t.oauth_id
11657 let profile_changed_at t = t.profile_changed_at
11658 let profile_image_path t = t.profile_image_path
11659 let quota_size_in_bytes t = t.quota_size_in_bytes
11660 let quota_usage_in_bytes t = t.quota_usage_in_bytes
11661 let should_change_password t = t.should_change_password
11662 let status t = t.status
11663 let storage_label t = t.storage_label
11664 let updated_at t = t.updated_at
11665
11666 let jsont : t Jsont.t =
11667 Jsont.Object.map ~kind:"UserAdminResponseDto"
11668 (fun avatar_color created_at deleted_at email id is_admin license name oauth_id profile_changed_at profile_image_path quota_size_in_bytes quota_usage_in_bytes should_change_password status storage_label updated_at -> { avatar_color; created_at; deleted_at; email; id; is_admin; license; name; oauth_id; profile_changed_at; profile_image_path; quota_size_in_bytes; quota_usage_in_bytes; should_change_password; status; storage_label; updated_at })
11669 |> Jsont.Object.mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
11670 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
11671 |> Jsont.Object.mem "deletedAt" Openapi.Runtime.nullable_ptime
11672 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.deleted_at)
11673 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
11674 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
11675 |> Jsont.Object.mem "isAdmin" Jsont.bool ~enc:(fun r -> r.is_admin)
11676 |> Jsont.Object.mem "license" UserLicense.T.jsont ~enc:(fun r -> r.license)
11677 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
11678 |> Jsont.Object.mem "oauthId" Jsont.string ~enc:(fun r -> r.oauth_id)
11679 |> Jsont.Object.mem "profileChangedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.profile_changed_at)
11680 |> Jsont.Object.mem "profileImagePath" Jsont.string ~enc:(fun r -> r.profile_image_path)
11681 |> Jsont.Object.mem "quotaSizeInBytes" (Openapi.Runtime.nullable_any Jsont.int64)
11682 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_size_in_bytes)
11683 |> Jsont.Object.mem "quotaUsageInBytes" (Openapi.Runtime.nullable_any Jsont.int64)
11684 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_usage_in_bytes)
11685 |> Jsont.Object.mem "shouldChangePassword" Jsont.bool ~enc:(fun r -> r.should_change_password)
11686 |> Jsont.Object.mem "status" User.Status.jsont ~enc:(fun r -> r.status)
11687 |> Jsont.Object.mem "storageLabel" Openapi.Runtime.nullable_string
11688 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.storage_label)
11689 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
11690 |> Jsont.Object.skip_unknown
11691 |> Jsont.Object.finish
11692 end
11693
11694 module CreateDto = struct
11695 include Types.CreateDto
11696
11697 let v ~email ~name ~password ?avatar_color ?is_admin ?notify ?quota_size_in_bytes ?should_change_password ?storage_label () = { avatar_color; email; is_admin; name; notify; password; quota_size_in_bytes; should_change_password; storage_label }
11698
11699 let avatar_color t = t.avatar_color
11700 let email t = t.email
11701 let is_admin t = t.is_admin
11702 let name t = t.name
11703 let notify t = t.notify
11704 let password t = t.password
11705 let quota_size_in_bytes t = t.quota_size_in_bytes
11706 let should_change_password t = t.should_change_password
11707 let storage_label t = t.storage_label
11708
11709 let jsont : t Jsont.t =
11710 Jsont.Object.map ~kind:"UserAdminCreateDto"
11711 (fun avatar_color email is_admin name notify password quota_size_in_bytes should_change_password storage_label -> { avatar_color; email; is_admin; name; notify; password; quota_size_in_bytes; should_change_password; storage_label })
11712 |> Jsont.Object.opt_mem "avatarColor" UserAvatarColor.T.jsont ~enc:(fun r -> r.avatar_color)
11713 |> Jsont.Object.mem "email" Jsont.string ~enc:(fun r -> r.email)
11714 |> Jsont.Object.opt_mem "isAdmin" Jsont.bool ~enc:(fun r -> r.is_admin)
11715 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
11716 |> Jsont.Object.opt_mem "notify" Jsont.bool ~enc:(fun r -> r.notify)
11717 |> Jsont.Object.mem "password" Jsont.string ~enc:(fun r -> r.password)
11718 |> Jsont.Object.mem "quotaSizeInBytes" (Openapi.Runtime.nullable_any Jsont.int64)
11719 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.quota_size_in_bytes)
11720 |> Jsont.Object.opt_mem "shouldChangePassword" Jsont.bool ~enc:(fun r -> r.should_change_password)
11721 |> Jsont.Object.mem "storageLabel" Openapi.Runtime.nullable_string
11722 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.storage_label)
11723 |> Jsont.Object.skip_unknown
11724 |> Jsont.Object.finish
11725 end
11726
11727 (** Search users
11728
11729 Search for users. *)
11730 let search_users_admin ?id ?with_deleted client () =
11731 let op_name = "search_users_admin" in
11732 let url_path = "/admin/users" in
11733 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"id" ~value:id; Openapi.Runtime.Query.optional ~key:"withDeleted" ~value:with_deleted]) in
11734 let url = client.base_url ^ url_path ^ query in
11735 let response =
11736 try Requests.get client.session url
11737 with Eio.Io _ as ex ->
11738 let bt = Printexc.get_raw_backtrace () in
11739 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
11740 in
11741 if Requests.Response.ok response then
11742 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11743 else
11744 let body = Requests.Response.text response in
11745 let parsed_body =
11746 match Jsont_bytesrw.decode_string Jsont.json body with
11747 | Ok json -> Some (Openapi.Runtime.Json json)
11748 | Error _ -> Some (Openapi.Runtime.Raw body)
11749 in
11750 raise (Openapi.Runtime.Api_error {
11751 operation = op_name;
11752 method_ = "GET";
11753 url;
11754 status = Requests.Response.status_code response;
11755 body;
11756 parsed_body;
11757 })
11758
11759 (** Create a user
11760
11761 Create a new user. *)
11762 let create_user_admin ~body client () =
11763 let op_name = "create_user_admin" in
11764 let url_path = "/admin/users" in
11765 let query = "" in
11766 let url = client.base_url ^ url_path ^ query in
11767 let response =
11768 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
11769 with Eio.Io _ as ex ->
11770 let bt = Printexc.get_raw_backtrace () in
11771 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11772 in
11773 if Requests.Response.ok response then
11774 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11775 else
11776 let body = Requests.Response.text response in
11777 let parsed_body =
11778 match Jsont_bytesrw.decode_string Jsont.json body with
11779 | Ok json -> Some (Openapi.Runtime.Json json)
11780 | Error _ -> Some (Openapi.Runtime.Raw body)
11781 in
11782 raise (Openapi.Runtime.Api_error {
11783 operation = op_name;
11784 method_ = "POST";
11785 url;
11786 status = Requests.Response.status_code response;
11787 body;
11788 parsed_body;
11789 })
11790
11791 (** Retrieve a user
11792
11793 Retrieve a specific user by their ID. *)
11794 let get_user_admin ~id client () =
11795 let op_name = "get_user_admin" in
11796 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}" in
11797 let query = "" in
11798 let url = client.base_url ^ url_path ^ query in
11799 let response =
11800 try Requests.get client.session url
11801 with Eio.Io _ as ex ->
11802 let bt = Printexc.get_raw_backtrace () in
11803 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
11804 in
11805 if Requests.Response.ok response then
11806 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11807 else
11808 let body = Requests.Response.text response in
11809 let parsed_body =
11810 match Jsont_bytesrw.decode_string Jsont.json body with
11811 | Ok json -> Some (Openapi.Runtime.Json json)
11812 | Error _ -> Some (Openapi.Runtime.Raw body)
11813 in
11814 raise (Openapi.Runtime.Api_error {
11815 operation = op_name;
11816 method_ = "GET";
11817 url;
11818 status = Requests.Response.status_code response;
11819 body;
11820 parsed_body;
11821 })
11822
11823 (** Update a user
11824
11825 Update an existing user. *)
11826 let update_user_admin ~id ~body client () =
11827 let op_name = "update_user_admin" in
11828 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}" in
11829 let query = "" in
11830 let url = client.base_url ^ url_path ^ query in
11831 let response =
11832 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
11833 with Eio.Io _ as ex ->
11834 let bt = Printexc.get_raw_backtrace () in
11835 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
11836 in
11837 if Requests.Response.ok response then
11838 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11839 else
11840 let body = Requests.Response.text response in
11841 let parsed_body =
11842 match Jsont_bytesrw.decode_string Jsont.json body with
11843 | Ok json -> Some (Openapi.Runtime.Json json)
11844 | Error _ -> Some (Openapi.Runtime.Raw body)
11845 in
11846 raise (Openapi.Runtime.Api_error {
11847 operation = op_name;
11848 method_ = "PUT";
11849 url;
11850 status = Requests.Response.status_code response;
11851 body;
11852 parsed_body;
11853 })
11854
11855 (** Delete a user
11856
11857 Delete a user. *)
11858 let delete_user_admin ~id client () =
11859 let op_name = "delete_user_admin" in
11860 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}" in
11861 let query = "" in
11862 let url = client.base_url ^ url_path ^ query in
11863 let response =
11864 try Requests.delete client.session url
11865 with Eio.Io _ as ex ->
11866 let bt = Printexc.get_raw_backtrace () in
11867 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
11868 in
11869 if Requests.Response.ok response then
11870 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11871 else
11872 let body = Requests.Response.text response in
11873 let parsed_body =
11874 match Jsont_bytesrw.decode_string Jsont.json body with
11875 | Ok json -> Some (Openapi.Runtime.Json json)
11876 | Error _ -> Some (Openapi.Runtime.Raw body)
11877 in
11878 raise (Openapi.Runtime.Api_error {
11879 operation = op_name;
11880 method_ = "DELETE";
11881 url;
11882 status = Requests.Response.status_code response;
11883 body;
11884 parsed_body;
11885 })
11886
11887 (** Restore a deleted user
11888
11889 Restore a previously deleted user. *)
11890 let restore_user_admin ~id client () =
11891 let op_name = "restore_user_admin" in
11892 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}/restore" in
11893 let query = "" in
11894 let url = client.base_url ^ url_path ^ query in
11895 let response =
11896 try Requests.post client.session url
11897 with Eio.Io _ as ex ->
11898 let bt = Printexc.get_raw_backtrace () in
11899 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11900 in
11901 if Requests.Response.ok response then
11902 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11903 else
11904 let body = Requests.Response.text response in
11905 let parsed_body =
11906 match Jsont_bytesrw.decode_string Jsont.json body with
11907 | Ok json -> Some (Openapi.Runtime.Json json)
11908 | Error _ -> Some (Openapi.Runtime.Raw body)
11909 in
11910 raise (Openapi.Runtime.Api_error {
11911 operation = op_name;
11912 method_ = "POST";
11913 url;
11914 status = Requests.Response.status_code response;
11915 body;
11916 parsed_body;
11917 })
11918
11919 (** Register admin
11920
11921 Create the first admin user in the system. *)
11922 let sign_up_admin ~body client () =
11923 let op_name = "sign_up_admin" in
11924 let url_path = "/auth/admin-sign-up" in
11925 let query = "" in
11926 let url = client.base_url ^ url_path ^ query in
11927 let response =
11928 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SignUp.Dto.jsont body)) url
11929 with Eio.Io _ as ex ->
11930 let bt = Printexc.get_raw_backtrace () in
11931 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11932 in
11933 if Requests.Response.ok response then
11934 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11935 else
11936 let body = Requests.Response.text response in
11937 let parsed_body =
11938 match Jsont_bytesrw.decode_string Jsont.json body with
11939 | Ok json -> Some (Openapi.Runtime.Json json)
11940 | Error _ -> Some (Openapi.Runtime.Raw body)
11941 in
11942 raise (Openapi.Runtime.Api_error {
11943 operation = op_name;
11944 method_ = "POST";
11945 url;
11946 status = Requests.Response.status_code response;
11947 body;
11948 parsed_body;
11949 })
11950
11951 (** Change password
11952
11953 Change the password of the current user. *)
11954 let change_password ~body client () =
11955 let op_name = "change_password" in
11956 let url_path = "/auth/change-password" in
11957 let query = "" in
11958 let url = client.base_url ^ url_path ^ query in
11959 let response =
11960 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json ChangePassword.Dto.jsont body)) url
11961 with Eio.Io _ as ex ->
11962 let bt = Printexc.get_raw_backtrace () in
11963 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11964 in
11965 if Requests.Response.ok response then
11966 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11967 else
11968 let body = Requests.Response.text response in
11969 let parsed_body =
11970 match Jsont_bytesrw.decode_string Jsont.json body with
11971 | Ok json -> Some (Openapi.Runtime.Json json)
11972 | Error _ -> Some (Openapi.Runtime.Raw body)
11973 in
11974 raise (Openapi.Runtime.Api_error {
11975 operation = op_name;
11976 method_ = "POST";
11977 url;
11978 status = Requests.Response.status_code response;
11979 body;
11980 parsed_body;
11981 })
11982
11983 (** Link OAuth account
11984
11985 Link an OAuth account to the authenticated user. *)
11986 let link_oauth_account ~body client () =
11987 let op_name = "link_oauth_account" in
11988 let url_path = "/oauth/link" in
11989 let query = "" in
11990 let url = client.base_url ^ url_path ^ query in
11991 let response =
11992 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json OauthCallback.Dto.jsont body)) url
11993 with Eio.Io _ as ex ->
11994 let bt = Printexc.get_raw_backtrace () in
11995 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
11996 in
11997 if Requests.Response.ok response then
11998 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
11999 else
12000 let body = Requests.Response.text response in
12001 let parsed_body =
12002 match Jsont_bytesrw.decode_string Jsont.json body with
12003 | Ok json -> Some (Openapi.Runtime.Json json)
12004 | Error _ -> Some (Openapi.Runtime.Raw body)
12005 in
12006 raise (Openapi.Runtime.Api_error {
12007 operation = op_name;
12008 method_ = "POST";
12009 url;
12010 status = Requests.Response.status_code response;
12011 body;
12012 parsed_body;
12013 })
12014
12015 (** Unlink OAuth account
12016
12017 Unlink the OAuth account from the authenticated user. *)
12018 let unlink_oauth_account client () =
12019 let op_name = "unlink_oauth_account" in
12020 let url_path = "/oauth/unlink" in
12021 let query = "" in
12022 let url = client.base_url ^ url_path ^ query in
12023 let response =
12024 try Requests.post client.session url
12025 with Eio.Io _ as ex ->
12026 let bt = Printexc.get_raw_backtrace () in
12027 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
12028 in
12029 if Requests.Response.ok response then
12030 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12031 else
12032 let body = Requests.Response.text response in
12033 let parsed_body =
12034 match Jsont_bytesrw.decode_string Jsont.json body with
12035 | Ok json -> Some (Openapi.Runtime.Json json)
12036 | Error _ -> Some (Openapi.Runtime.Raw body)
12037 in
12038 raise (Openapi.Runtime.Api_error {
12039 operation = op_name;
12040 method_ = "POST";
12041 url;
12042 status = Requests.Response.status_code response;
12043 body;
12044 parsed_body;
12045 })
12046
12047 (** Get current user
12048
12049 Retrieve information about the user making the API request. *)
12050 let get_my_user client () =
12051 let op_name = "get_my_user" in
12052 let url_path = "/users/me" in
12053 let query = "" in
12054 let url = client.base_url ^ url_path ^ query in
12055 let response =
12056 try Requests.get client.session url
12057 with Eio.Io _ as ex ->
12058 let bt = Printexc.get_raw_backtrace () in
12059 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
12060 in
12061 if Requests.Response.ok response then
12062 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12063 else
12064 let body = Requests.Response.text response in
12065 let parsed_body =
12066 match Jsont_bytesrw.decode_string Jsont.json body with
12067 | Ok json -> Some (Openapi.Runtime.Json json)
12068 | Error _ -> Some (Openapi.Runtime.Raw body)
12069 in
12070 raise (Openapi.Runtime.Api_error {
12071 operation = op_name;
12072 method_ = "GET";
12073 url;
12074 status = Requests.Response.status_code response;
12075 body;
12076 parsed_body;
12077 })
12078
12079 (** Update current user
12080
12081 Update the current user making teh API request. *)
12082 let update_my_user ~body client () =
12083 let op_name = "update_my_user" in
12084 let url_path = "/users/me" in
12085 let query = "" in
12086 let url = client.base_url ^ url_path ^ query in
12087 let response =
12088 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UserUpdateMe.Dto.jsont body)) url
12089 with Eio.Io _ as ex ->
12090 let bt = Printexc.get_raw_backtrace () in
12091 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
12092 in
12093 if Requests.Response.ok response then
12094 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12095 else
12096 let body = Requests.Response.text response in
12097 let parsed_body =
12098 match Jsont_bytesrw.decode_string Jsont.json body with
12099 | Ok json -> Some (Openapi.Runtime.Json json)
12100 | Error _ -> Some (Openapi.Runtime.Raw body)
12101 in
12102 raise (Openapi.Runtime.Api_error {
12103 operation = op_name;
12104 method_ = "PUT";
12105 url;
12106 status = Requests.Response.status_code response;
12107 body;
12108 parsed_body;
12109 })
12110end
12111
12112module Cast = struct
12113 module Types = struct
12114 module Update = struct
12115 type t = {
12116 g_cast_enabled : bool option;
12117 }
12118 end
12119
12120 module Response = struct
12121 type t = {
12122 g_cast_enabled : bool;
12123 }
12124 end
12125 end
12126
12127 module Update = struct
12128 include Types.Update
12129
12130 let v ?g_cast_enabled () = { g_cast_enabled }
12131
12132 let g_cast_enabled t = t.g_cast_enabled
12133
12134 let jsont : t Jsont.t =
12135 Jsont.Object.map ~kind:"CastUpdate"
12136 (fun g_cast_enabled -> { g_cast_enabled })
12137 |> Jsont.Object.opt_mem "gCastEnabled" Jsont.bool ~enc:(fun r -> r.g_cast_enabled)
12138 |> Jsont.Object.skip_unknown
12139 |> Jsont.Object.finish
12140 end
12141
12142 module Response = struct
12143 include Types.Response
12144
12145 let v ?(g_cast_enabled=false) () = { g_cast_enabled }
12146
12147 let g_cast_enabled t = t.g_cast_enabled
12148
12149 let jsont : t Jsont.t =
12150 Jsont.Object.map ~kind:"CastResponse"
12151 (fun g_cast_enabled -> { g_cast_enabled })
12152 |> Jsont.Object.mem "gCastEnabled" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.g_cast_enabled)
12153 |> Jsont.Object.skip_unknown
12154 |> Jsont.Object.finish
12155 end
12156end
12157
12158module BulkIds = struct
12159 module Types = struct
12160 module Dto = struct
12161 type t = {
12162 ids : string list;
12163 }
12164 end
12165 end
12166
12167 module Dto = struct
12168 include Types.Dto
12169
12170 let v ~ids () = { ids }
12171
12172 let ids t = t.ids
12173
12174 let jsont : t Jsont.t =
12175 Jsont.Object.map ~kind:"BulkIdsDto"
12176 (fun ids -> { ids })
12177 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
12178 |> Jsont.Object.skip_unknown
12179 |> Jsont.Object.finish
12180 end
12181end
12182
12183module Trash = struct
12184 module Types = struct
12185 module ResponseDto = struct
12186 type t = {
12187 count : int;
12188 }
12189 end
12190 end
12191
12192 module ResponseDto = struct
12193 include Types.ResponseDto
12194
12195 let v ~count () = { count }
12196
12197 let count t = t.count
12198
12199 let jsont : t Jsont.t =
12200 Jsont.Object.map ~kind:"TrashResponseDto"
12201 (fun count -> { count })
12202 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
12203 |> Jsont.Object.skip_unknown
12204 |> Jsont.Object.finish
12205 end
12206
12207 (** Empty trash
12208
12209 Permanently delete all items in the trash. *)
12210 let empty_trash client () =
12211 let op_name = "empty_trash" in
12212 let url_path = "/trash/empty" in
12213 let query = "" in
12214 let url = client.base_url ^ url_path ^ query in
12215 let response =
12216 try Requests.post client.session url
12217 with Eio.Io _ as ex ->
12218 let bt = Printexc.get_raw_backtrace () in
12219 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
12220 in
12221 if Requests.Response.ok response then
12222 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12223 else
12224 let body = Requests.Response.text response in
12225 let parsed_body =
12226 match Jsont_bytesrw.decode_string Jsont.json body with
12227 | Ok json -> Some (Openapi.Runtime.Json json)
12228 | Error _ -> Some (Openapi.Runtime.Raw body)
12229 in
12230 raise (Openapi.Runtime.Api_error {
12231 operation = op_name;
12232 method_ = "POST";
12233 url;
12234 status = Requests.Response.status_code response;
12235 body;
12236 parsed_body;
12237 })
12238
12239 (** Restore trash
12240
12241 Restore all items in the trash. *)
12242 let restore_trash client () =
12243 let op_name = "restore_trash" in
12244 let url_path = "/trash/restore" in
12245 let query = "" in
12246 let url = client.base_url ^ url_path ^ query in
12247 let response =
12248 try Requests.post client.session url
12249 with Eio.Io _ as ex ->
12250 let bt = Printexc.get_raw_backtrace () in
12251 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
12252 in
12253 if Requests.Response.ok response then
12254 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12255 else
12256 let body = Requests.Response.text response in
12257 let parsed_body =
12258 match Jsont_bytesrw.decode_string Jsont.json body with
12259 | Ok json -> Some (Openapi.Runtime.Json json)
12260 | Error _ -> Some (Openapi.Runtime.Raw body)
12261 in
12262 raise (Openapi.Runtime.Api_error {
12263 operation = op_name;
12264 method_ = "POST";
12265 url;
12266 status = Requests.Response.status_code response;
12267 body;
12268 parsed_body;
12269 })
12270
12271 (** Restore assets
12272
12273 Restore specific assets from the trash. *)
12274 let restore_assets ~body client () =
12275 let op_name = "restore_assets" in
12276 let url_path = "/trash/restore/assets" in
12277 let query = "" in
12278 let url = client.base_url ^ url_path ^ query in
12279 let response =
12280 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json BulkIds.Dto.jsont body)) url
12281 with Eio.Io _ as ex ->
12282 let bt = Printexc.get_raw_backtrace () in
12283 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
12284 in
12285 if Requests.Response.ok response then
12286 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12287 else
12288 let body = Requests.Response.text response in
12289 let parsed_body =
12290 match Jsont_bytesrw.decode_string Jsont.json body with
12291 | Ok json -> Some (Openapi.Runtime.Json json)
12292 | Error _ -> Some (Openapi.Runtime.Raw body)
12293 in
12294 raise (Openapi.Runtime.Api_error {
12295 operation = op_name;
12296 method_ = "POST";
12297 url;
12298 status = Requests.Response.status_code response;
12299 body;
12300 parsed_body;
12301 })
12302end
12303
12304module BulkIdErrorReason = struct
12305 module Types = struct
12306 module T = struct
12307 type t = [
12308 | `Duplicate
12309 | `No_permission
12310 | `Not_found
12311 | `Unknown
12312 ]
12313 end
12314 end
12315
12316 module T = struct
12317 include Types.T
12318
12319 let jsont : t Jsont.t =
12320 Jsont.map Jsont.string ~kind:"BulkIdErrorReason"
12321 ~dec:(function
12322 | "duplicate" -> `Duplicate
12323 | "no_permission" -> `No_permission
12324 | "not_found" -> `Not_found
12325 | "unknown" -> `Unknown
12326 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
12327 ~enc:(function
12328 | `Duplicate -> "duplicate"
12329 | `No_permission -> "no_permission"
12330 | `Not_found -> "not_found"
12331 | `Unknown -> "unknown")
12332 end
12333end
12334
12335module AlbumsAddAssets = struct
12336 module Types = struct
12337 module ResponseDto = struct
12338 type t = {
12339 error : BulkIdErrorReason.T.t option;
12340 success : bool;
12341 }
12342 end
12343
12344 module Dto = struct
12345 type t = {
12346 album_ids : string list;
12347 asset_ids : string list;
12348 }
12349 end
12350 end
12351
12352 module ResponseDto = struct
12353 include Types.ResponseDto
12354
12355 let v ~success ?error () = { error; success }
12356
12357 let error t = t.error
12358 let success t = t.success
12359
12360 let jsont : t Jsont.t =
12361 Jsont.Object.map ~kind:"AlbumsAddAssetsResponseDto"
12362 (fun error success -> { error; success })
12363 |> Jsont.Object.opt_mem "error" BulkIdErrorReason.T.jsont ~enc:(fun r -> r.error)
12364 |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
12365 |> Jsont.Object.skip_unknown
12366 |> Jsont.Object.finish
12367 end
12368
12369 module Dto = struct
12370 include Types.Dto
12371
12372 let v ~album_ids ~asset_ids () = { album_ids; asset_ids }
12373
12374 let album_ids t = t.album_ids
12375 let asset_ids t = t.asset_ids
12376
12377 let jsont : t Jsont.t =
12378 Jsont.Object.map ~kind:"AlbumsAddAssetsDto"
12379 (fun album_ids asset_ids -> { album_ids; asset_ids })
12380 |> Jsont.Object.mem "albumIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.album_ids)
12381 |> Jsont.Object.mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
12382 |> Jsont.Object.skip_unknown
12383 |> Jsont.Object.finish
12384 end
12385
12386 (** Add assets to albums
12387
12388 Send a list of asset IDs and album IDs to add each asset to each album. *)
12389 let add_assets_to_albums ?key ?slug ~body client () =
12390 let op_name = "add_assets_to_albums" in
12391 let url_path = "/albums/assets" in
12392 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
12393 let url = client.base_url ^ url_path ^ query in
12394 let response =
12395 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
12396 with Eio.Io _ as ex ->
12397 let bt = Printexc.get_raw_backtrace () in
12398 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
12399 in
12400 if Requests.Response.ok response then
12401 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12402 else
12403 let body = Requests.Response.text response in
12404 let parsed_body =
12405 match Jsont_bytesrw.decode_string Jsont.json body with
12406 | Ok json -> Some (Openapi.Runtime.Json json)
12407 | Error _ -> Some (Openapi.Runtime.Raw body)
12408 in
12409 raise (Openapi.Runtime.Api_error {
12410 operation = op_name;
12411 method_ = "PUT";
12412 url;
12413 status = Requests.Response.status_code response;
12414 body;
12415 parsed_body;
12416 })
12417end
12418
12419module AuthStatus = struct
12420 module Types = struct
12421 module ResponseDto = struct
12422 type t = {
12423 expires_at : string option;
12424 is_elevated : bool;
12425 password : bool;
12426 pin_code : bool;
12427 pin_expires_at : string option;
12428 }
12429 end
12430 end
12431
12432 module ResponseDto = struct
12433 include Types.ResponseDto
12434
12435 let v ~is_elevated ~password ~pin_code ?expires_at ?pin_expires_at () = { expires_at; is_elevated; password; pin_code; pin_expires_at }
12436
12437 let expires_at t = t.expires_at
12438 let is_elevated t = t.is_elevated
12439 let password t = t.password
12440 let pin_code t = t.pin_code
12441 let pin_expires_at t = t.pin_expires_at
12442
12443 let jsont : t Jsont.t =
12444 Jsont.Object.map ~kind:"AuthStatusResponseDto"
12445 (fun expires_at is_elevated password pin_code pin_expires_at -> { expires_at; is_elevated; password; pin_code; pin_expires_at })
12446 |> Jsont.Object.opt_mem "expiresAt" Jsont.string ~enc:(fun r -> r.expires_at)
12447 |> Jsont.Object.mem "isElevated" Jsont.bool ~enc:(fun r -> r.is_elevated)
12448 |> Jsont.Object.mem "password" Jsont.bool ~enc:(fun r -> r.password)
12449 |> Jsont.Object.mem "pinCode" Jsont.bool ~enc:(fun r -> r.pin_code)
12450 |> Jsont.Object.opt_mem "pinExpiresAt" Jsont.string ~enc:(fun r -> r.pin_expires_at)
12451 |> Jsont.Object.skip_unknown
12452 |> Jsont.Object.finish
12453 end
12454
12455 (** Retrieve auth status
12456
12457 Get information about the current session, including whether the user has a password, and if the session can access locked assets. *)
12458 let get_auth_status client () =
12459 let op_name = "get_auth_status" in
12460 let url_path = "/auth/status" in
12461 let query = "" in
12462 let url = client.base_url ^ url_path ^ query in
12463 let response =
12464 try Requests.get client.session url
12465 with Eio.Io _ as ex ->
12466 let bt = Printexc.get_raw_backtrace () in
12467 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
12468 in
12469 if Requests.Response.ok response then
12470 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12471 else
12472 let body = Requests.Response.text response in
12473 let parsed_body =
12474 match Jsont_bytesrw.decode_string Jsont.json body with
12475 | Ok json -> Some (Openapi.Runtime.Json json)
12476 | Error _ -> Some (Openapi.Runtime.Raw body)
12477 in
12478 raise (Openapi.Runtime.Api_error {
12479 operation = op_name;
12480 method_ = "GET";
12481 url;
12482 status = Requests.Response.status_code response;
12483 body;
12484 parsed_body;
12485 })
12486end
12487
12488module AudioCodec = struct
12489 module Types = struct
12490 module T = struct
12491 type t = [
12492 | `Mp3
12493 | `Aac
12494 | `Libopus
12495 | `Pcm_s16le
12496 ]
12497 end
12498 end
12499
12500 module T = struct
12501 include Types.T
12502
12503 let jsont : t Jsont.t =
12504 Jsont.map Jsont.string ~kind:"AudioCodec"
12505 ~dec:(function
12506 | "mp3" -> `Mp3
12507 | "aac" -> `Aac
12508 | "libopus" -> `Libopus
12509 | "pcm_s16le" -> `Pcm_s16le
12510 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
12511 ~enc:(function
12512 | `Mp3 -> "mp3"
12513 | `Aac -> "aac"
12514 | `Libopus -> "libopus"
12515 | `Pcm_s16le -> "pcm_s16le")
12516 end
12517end
12518
12519module SystemConfigFfmpeg = struct
12520 module Types = struct
12521 module Dto = struct
12522 type t = {
12523 accel : TranscodeHwaccel.T.t;
12524 accel_decode : bool;
12525 accepted_audio_codecs : AudioCodec.T.t list;
12526 accepted_containers : VideoContainer.T.t list;
12527 accepted_video_codecs : VideoCodec.T.t list;
12528 bframes : int;
12529 cq_mode : Cqmode.T.t;
12530 crf : int;
12531 gop_size : int;
12532 max_bitrate : string;
12533 preferred_hw_device : string;
12534 preset : string;
12535 refs : int;
12536 target_audio_codec : AudioCodec.T.t;
12537 target_resolution : string;
12538 target_video_codec : VideoCodec.T.t;
12539 temporal_aq : bool;
12540 threads : int;
12541 tonemap : ToneMapping.T.t;
12542 transcode : TranscodePolicy.T.t;
12543 two_pass : bool;
12544 }
12545 end
12546 end
12547
12548 module Dto = struct
12549 include Types.Dto
12550
12551 let v ~accel ~accel_decode ~accepted_audio_codecs ~accepted_containers ~accepted_video_codecs ~bframes ~cq_mode ~crf ~gop_size ~max_bitrate ~preferred_hw_device ~preset ~refs ~target_audio_codec ~target_resolution ~target_video_codec ~temporal_aq ~threads ~tonemap ~transcode ~two_pass () = { accel; accel_decode; accepted_audio_codecs; accepted_containers; accepted_video_codecs; bframes; cq_mode; crf; gop_size; max_bitrate; preferred_hw_device; preset; refs; target_audio_codec; target_resolution; target_video_codec; temporal_aq; threads; tonemap; transcode; two_pass }
12552
12553 let accel t = t.accel
12554 let accel_decode t = t.accel_decode
12555 let accepted_audio_codecs t = t.accepted_audio_codecs
12556 let accepted_containers t = t.accepted_containers
12557 let accepted_video_codecs t = t.accepted_video_codecs
12558 let bframes t = t.bframes
12559 let cq_mode t = t.cq_mode
12560 let crf t = t.crf
12561 let gop_size t = t.gop_size
12562 let max_bitrate t = t.max_bitrate
12563 let preferred_hw_device t = t.preferred_hw_device
12564 let preset t = t.preset
12565 let refs t = t.refs
12566 let target_audio_codec t = t.target_audio_codec
12567 let target_resolution t = t.target_resolution
12568 let target_video_codec t = t.target_video_codec
12569 let temporal_aq t = t.temporal_aq
12570 let threads t = t.threads
12571 let tonemap t = t.tonemap
12572 let transcode t = t.transcode
12573 let two_pass t = t.two_pass
12574
12575 let jsont : t Jsont.t =
12576 Jsont.Object.map ~kind:"SystemConfigFFmpegDto"
12577 (fun accel accel_decode accepted_audio_codecs accepted_containers accepted_video_codecs bframes cq_mode crf gop_size max_bitrate preferred_hw_device preset refs target_audio_codec target_resolution target_video_codec temporal_aq threads tonemap transcode two_pass -> { accel; accel_decode; accepted_audio_codecs; accepted_containers; accepted_video_codecs; bframes; cq_mode; crf; gop_size; max_bitrate; preferred_hw_device; preset; refs; target_audio_codec; target_resolution; target_video_codec; temporal_aq; threads; tonemap; transcode; two_pass })
12578 |> Jsont.Object.mem "accel" TranscodeHwaccel.T.jsont ~enc:(fun r -> r.accel)
12579 |> Jsont.Object.mem "accelDecode" Jsont.bool ~enc:(fun r -> r.accel_decode)
12580 |> Jsont.Object.mem "acceptedAudioCodecs" (Jsont.list AudioCodec.T.jsont) ~enc:(fun r -> r.accepted_audio_codecs)
12581 |> Jsont.Object.mem "acceptedContainers" (Jsont.list VideoContainer.T.jsont) ~enc:(fun r -> r.accepted_containers)
12582 |> Jsont.Object.mem "acceptedVideoCodecs" (Jsont.list VideoCodec.T.jsont) ~enc:(fun r -> r.accepted_video_codecs)
12583 |> Jsont.Object.mem "bframes" (Openapi.Runtime.validated_int ~minimum:(-1.) ~maximum:16. Jsont.int) ~enc:(fun r -> r.bframes)
12584 |> Jsont.Object.mem "cqMode" Cqmode.T.jsont ~enc:(fun r -> r.cq_mode)
12585 |> Jsont.Object.mem "crf" (Openapi.Runtime.validated_int ~minimum:0. ~maximum:51. Jsont.int) ~enc:(fun r -> r.crf)
12586 |> Jsont.Object.mem "gopSize" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.gop_size)
12587 |> Jsont.Object.mem "maxBitrate" Jsont.string ~enc:(fun r -> r.max_bitrate)
12588 |> Jsont.Object.mem "preferredHwDevice" Jsont.string ~enc:(fun r -> r.preferred_hw_device)
12589 |> Jsont.Object.mem "preset" Jsont.string ~enc:(fun r -> r.preset)
12590 |> Jsont.Object.mem "refs" (Openapi.Runtime.validated_int ~minimum:0. ~maximum:6. Jsont.int) ~enc:(fun r -> r.refs)
12591 |> Jsont.Object.mem "targetAudioCodec" AudioCodec.T.jsont ~enc:(fun r -> r.target_audio_codec)
12592 |> Jsont.Object.mem "targetResolution" Jsont.string ~enc:(fun r -> r.target_resolution)
12593 |> Jsont.Object.mem "targetVideoCodec" VideoCodec.T.jsont ~enc:(fun r -> r.target_video_codec)
12594 |> Jsont.Object.mem "temporalAQ" Jsont.bool ~enc:(fun r -> r.temporal_aq)
12595 |> Jsont.Object.mem "threads" (Openapi.Runtime.validated_int ~minimum:0. Jsont.int) ~enc:(fun r -> r.threads)
12596 |> Jsont.Object.mem "tonemap" ToneMapping.T.jsont ~enc:(fun r -> r.tonemap)
12597 |> Jsont.Object.mem "transcode" TranscodePolicy.T.jsont ~enc:(fun r -> r.transcode)
12598 |> Jsont.Object.mem "twoPass" Jsont.bool ~enc:(fun r -> r.two_pass)
12599 |> Jsont.Object.skip_unknown
12600 |> Jsont.Object.finish
12601 end
12602end
12603
12604module SystemConfig = struct
12605 module Types = struct
12606 module Dto = struct
12607 type t = {
12608 backup : SystemConfigBackups.Dto.t;
12609 ffmpeg : SystemConfigFfmpeg.Dto.t;
12610 image : SystemConfigImage.Dto.t;
12611 job : SystemConfigJob.Dto.t;
12612 library : SystemConfigLibrary.Dto.t;
12613 logging : SystemConfigLogging.Dto.t;
12614 machine_learning : SystemConfigMachineLearning.Dto.t;
12615 map : SystemConfigMap.Dto.t;
12616 metadata : SystemConfigMetadata.Dto.t;
12617 new_version_check : SystemConfigNewVersionCheck.Dto.t;
12618 nightly_tasks : SystemConfigNightlyTasks.Dto.t;
12619 notifications : SystemConfigNotifications.Dto.t;
12620 oauth : SystemConfigOauth.Dto.t;
12621 password_login : SystemConfigPasswordLogin.Dto.t;
12622 reverse_geocoding : SystemConfigReverseGeocoding.Dto.t;
12623 server : SystemConfigServer.Dto.t;
12624 storage_template : SystemConfigStorageTemplate.Dto.t;
12625 templates : SystemConfigTemplates.Dto.t;
12626 theme : SystemConfigTheme.Dto.t;
12627 trash : SystemConfigTrash.Dto.t;
12628 user : SystemConfigUser.Dto.t;
12629 }
12630 end
12631 end
12632
12633 module Dto = struct
12634 include Types.Dto
12635
12636 let v ~backup ~ffmpeg ~image ~job ~library ~logging ~machine_learning ~map ~metadata ~new_version_check ~nightly_tasks ~notifications ~oauth ~password_login ~reverse_geocoding ~server ~storage_template ~templates ~theme ~trash ~user () = { backup; ffmpeg; image; job; library; logging; machine_learning; map; metadata; new_version_check; nightly_tasks; notifications; oauth; password_login; reverse_geocoding; server; storage_template; templates; theme; trash; user }
12637
12638 let backup t = t.backup
12639 let ffmpeg t = t.ffmpeg
12640 let image t = t.image
12641 let job t = t.job
12642 let library t = t.library
12643 let logging t = t.logging
12644 let machine_learning t = t.machine_learning
12645 let map t = t.map
12646 let metadata t = t.metadata
12647 let new_version_check t = t.new_version_check
12648 let nightly_tasks t = t.nightly_tasks
12649 let notifications t = t.notifications
12650 let oauth t = t.oauth
12651 let password_login t = t.password_login
12652 let reverse_geocoding t = t.reverse_geocoding
12653 let server t = t.server
12654 let storage_template t = t.storage_template
12655 let templates t = t.templates
12656 let theme t = t.theme
12657 let trash t = t.trash
12658 let user t = t.user
12659
12660 let jsont : t Jsont.t =
12661 Jsont.Object.map ~kind:"SystemConfigDto"
12662 (fun backup ffmpeg image job library logging machine_learning map metadata new_version_check nightly_tasks notifications oauth password_login reverse_geocoding server storage_template templates theme trash user -> { backup; ffmpeg; image; job; library; logging; machine_learning; map; metadata; new_version_check; nightly_tasks; notifications; oauth; password_login; reverse_geocoding; server; storage_template; templates; theme; trash; user })
12663 |> Jsont.Object.mem "backup" SystemConfigBackups.Dto.jsont ~enc:(fun r -> r.backup)
12664 |> Jsont.Object.mem "ffmpeg" SystemConfigFfmpeg.Dto.jsont ~enc:(fun r -> r.ffmpeg)
12665 |> Jsont.Object.mem "image" SystemConfigImage.Dto.jsont ~enc:(fun r -> r.image)
12666 |> Jsont.Object.mem "job" SystemConfigJob.Dto.jsont ~enc:(fun r -> r.job)
12667 |> Jsont.Object.mem "library" SystemConfigLibrary.Dto.jsont ~enc:(fun r -> r.library)
12668 |> Jsont.Object.mem "logging" SystemConfigLogging.Dto.jsont ~enc:(fun r -> r.logging)
12669 |> Jsont.Object.mem "machineLearning" SystemConfigMachineLearning.Dto.jsont ~enc:(fun r -> r.machine_learning)
12670 |> Jsont.Object.mem "map" SystemConfigMap.Dto.jsont ~enc:(fun r -> r.map)
12671 |> Jsont.Object.mem "metadata" SystemConfigMetadata.Dto.jsont ~enc:(fun r -> r.metadata)
12672 |> Jsont.Object.mem "newVersionCheck" SystemConfigNewVersionCheck.Dto.jsont ~enc:(fun r -> r.new_version_check)
12673 |> Jsont.Object.mem "nightlyTasks" SystemConfigNightlyTasks.Dto.jsont ~enc:(fun r -> r.nightly_tasks)
12674 |> Jsont.Object.mem "notifications" SystemConfigNotifications.Dto.jsont ~enc:(fun r -> r.notifications)
12675 |> Jsont.Object.mem "oauth" SystemConfigOauth.Dto.jsont ~enc:(fun r -> r.oauth)
12676 |> Jsont.Object.mem "passwordLogin" SystemConfigPasswordLogin.Dto.jsont ~enc:(fun r -> r.password_login)
12677 |> Jsont.Object.mem "reverseGeocoding" SystemConfigReverseGeocoding.Dto.jsont ~enc:(fun r -> r.reverse_geocoding)
12678 |> Jsont.Object.mem "server" SystemConfigServer.Dto.jsont ~enc:(fun r -> r.server)
12679 |> Jsont.Object.mem "storageTemplate" SystemConfigStorageTemplate.Dto.jsont ~enc:(fun r -> r.storage_template)
12680 |> Jsont.Object.mem "templates" SystemConfigTemplates.Dto.jsont ~enc:(fun r -> r.templates)
12681 |> Jsont.Object.mem "theme" SystemConfigTheme.Dto.jsont ~enc:(fun r -> r.theme)
12682 |> Jsont.Object.mem "trash" SystemConfigTrash.Dto.jsont ~enc:(fun r -> r.trash)
12683 |> Jsont.Object.mem "user" SystemConfigUser.Dto.jsont ~enc:(fun r -> r.user)
12684 |> Jsont.Object.skip_unknown
12685 |> Jsont.Object.finish
12686 end
12687
12688 (** Get system configuration
12689
12690 Retrieve the current system configuration. *)
12691 let get_config client () =
12692 let op_name = "get_config" in
12693 let url_path = "/system-config" in
12694 let query = "" in
12695 let url = client.base_url ^ url_path ^ query in
12696 let response =
12697 try Requests.get client.session url
12698 with Eio.Io _ as ex ->
12699 let bt = Printexc.get_raw_backtrace () in
12700 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
12701 in
12702 if Requests.Response.ok response then
12703 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
12704 else
12705 let body = Requests.Response.text response in
12706 let parsed_body =
12707 match Jsont_bytesrw.decode_string Jsont.json body with
12708 | Ok json -> Some (Openapi.Runtime.Json json)
12709 | Error _ -> Some (Openapi.Runtime.Raw body)
12710 in
12711 raise (Openapi.Runtime.Api_error {
12712 operation = op_name;
12713 method_ = "GET";
12714 url;
12715 status = Requests.Response.status_code response;
12716 body;
12717 parsed_body;
12718 })
12719
12720 (** Update system configuration
12721
12722 Update the system configuration with a new system configuration. *)
12723 let update_config ~body client () =
12724 let op_name = "update_config" in
12725 let url_path = "/system-config" in
12726 let query = "" in
12727 let url = client.base_url ^ url_path ^ query in
12728 let response =
12729 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
12730 with Eio.Io _ as ex ->
12731 let bt = Printexc.get_raw_backtrace () in
12732 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
12733 in
12734 if Requests.Response.ok response then
12735 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
12736 else
12737 let body = Requests.Response.text response in
12738 let parsed_body =
12739 match Jsont_bytesrw.decode_string Jsont.json body with
12740 | Ok json -> Some (Openapi.Runtime.Json json)
12741 | Error _ -> Some (Openapi.Runtime.Raw body)
12742 in
12743 raise (Openapi.Runtime.Api_error {
12744 operation = op_name;
12745 method_ = "PUT";
12746 url;
12747 status = Requests.Response.status_code response;
12748 body;
12749 parsed_body;
12750 })
12751
12752 (** Get system configuration defaults
12753
12754 Retrieve the default values for the system configuration. *)
12755 let get_config_defaults client () =
12756 let op_name = "get_config_defaults" in
12757 let url_path = "/system-config/defaults" in
12758 let query = "" in
12759 let url = client.base_url ^ url_path ^ query in
12760 let response =
12761 try Requests.get client.session url
12762 with Eio.Io _ as ex ->
12763 let bt = Printexc.get_raw_backtrace () in
12764 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
12765 in
12766 if Requests.Response.ok response then
12767 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
12768 else
12769 let body = Requests.Response.text response in
12770 let parsed_body =
12771 match Jsont_bytesrw.decode_string Jsont.json body with
12772 | Ok json -> Some (Openapi.Runtime.Json json)
12773 | Error _ -> Some (Openapi.Runtime.Raw body)
12774 in
12775 raise (Openapi.Runtime.Api_error {
12776 operation = op_name;
12777 method_ = "GET";
12778 url;
12779 status = Requests.Response.status_code response;
12780 body;
12781 parsed_body;
12782 })
12783end
12784
12785module AssetVisibility = struct
12786 module Types = struct
12787 module T = struct
12788 type t = [
12789 | `Archive
12790 | `Timeline
12791 | `Hidden
12792 | `Locked
12793 ]
12794 end
12795 end
12796
12797 module T = struct
12798 include Types.T
12799
12800 let jsont : t Jsont.t =
12801 Jsont.map Jsont.string ~kind:"AssetVisibility"
12802 ~dec:(function
12803 | "archive" -> `Archive
12804 | "timeline" -> `Timeline
12805 | "hidden" -> `Hidden
12806 | "locked" -> `Locked
12807 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
12808 ~enc:(function
12809 | `Archive -> "archive"
12810 | `Timeline -> "timeline"
12811 | `Hidden -> "hidden"
12812 | `Locked -> "locked")
12813 end
12814end
12815
12816module UpdateAsset = struct
12817 module Types = struct
12818 module Dto = struct
12819 type t = {
12820 date_time_original : string option;
12821 description : string option;
12822 is_favorite : bool option;
12823 latitude : float option;
12824 live_photo_video_id : string option;
12825 longitude : float option;
12826 rating : float option;
12827 visibility : AssetVisibility.T.t option;
12828 }
12829 end
12830 end
12831
12832 module Dto = struct
12833 include Types.Dto
12834
12835 let v ?date_time_original ?description ?is_favorite ?latitude ?live_photo_video_id ?longitude ?rating ?visibility () = { date_time_original; description; is_favorite; latitude; live_photo_video_id; longitude; rating; visibility }
12836
12837 let date_time_original t = t.date_time_original
12838 let description t = t.description
12839 let is_favorite t = t.is_favorite
12840 let latitude t = t.latitude
12841 let live_photo_video_id t = t.live_photo_video_id
12842 let longitude t = t.longitude
12843 let rating t = t.rating
12844 let visibility t = t.visibility
12845
12846 let jsont : t Jsont.t =
12847 Jsont.Object.map ~kind:"UpdateAssetDto"
12848 (fun date_time_original description is_favorite latitude live_photo_video_id longitude rating visibility -> { date_time_original; description; is_favorite; latitude; live_photo_video_id; longitude; rating; visibility })
12849 |> Jsont.Object.opt_mem "dateTimeOriginal" Jsont.string ~enc:(fun r -> r.date_time_original)
12850 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
12851 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
12852 |> Jsont.Object.opt_mem "latitude" Jsont.number ~enc:(fun r -> r.latitude)
12853 |> Jsont.Object.mem "livePhotoVideoId" Openapi.Runtime.nullable_string
12854 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.live_photo_video_id)
12855 |> Jsont.Object.opt_mem "longitude" Jsont.number ~enc:(fun r -> r.longitude)
12856 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
12857 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
12858 |> Jsont.Object.skip_unknown
12859 |> Jsont.Object.finish
12860 end
12861end
12862
12863module TimeBucketAsset = struct
12864 module Types = struct
12865 module ResponseDto = struct
12866 type t = {
12867 city : string list; (** Array of city names extracted from EXIF GPS data *)
12868 country : string list; (** Array of country names extracted from EXIF GPS data *)
12869 duration : string list; (** Array of video durations in HH:MM:SS format (null for images) *)
12870 file_created_at : string list; (** Array of file creation timestamps in UTC (ISO 8601 format, without timezone) *)
12871 id : string list; (** Array of asset IDs in the time bucket *)
12872 is_favorite : bool list; (** Array indicating whether each asset is favorited *)
12873 is_image : bool list; (** Array indicating whether each asset is an image (false for videos) *)
12874 is_trashed : bool list; (** Array indicating whether each asset is in the trash *)
12875 latitude : float list option; (** Array of latitude coordinates extracted from EXIF GPS data *)
12876 live_photo_video_id : string list; (** Array of live photo video asset IDs (null for non-live photos) *)
12877 local_offset_hours : float list; (** Array of UTC offset hours at the time each photo was taken. Positive values are east of UTC, negative values are west of UTC. Values may be fractional (e.g., 5.5 for +05:30, -9.75 for -09:45). Applying this offset to 'fileCreatedAt' will give you the time the photo was taken from the photographer's perspective. *)
12878 longitude : float list option; (** Array of longitude coordinates extracted from EXIF GPS data *)
12879 owner_id : string list; (** Array of owner IDs for each asset *)
12880 projection_type : string list; (** Array of projection types for 360° content (e.g., "EQUIRECTANGULAR", "CUBEFACE", "CYLINDRICAL") *)
12881 ratio : float list; (** Array of aspect ratios (width/height) for each asset *)
12882 stack : string list list option; (** Array of stack information as [stackId, assetCount] tuples (null for non-stacked assets) *)
12883 thumbhash : string list; (** Array of BlurHash strings for generating asset previews (base64 encoded) *)
12884 visibility : AssetVisibility.T.t list; (** Array of visibility statuses for each asset (e.g., ARCHIVE, TIMELINE, HIDDEN, LOCKED) *)
12885 }
12886 end
12887 end
12888
12889 module ResponseDto = struct
12890 include Types.ResponseDto
12891
12892 let v ~city ~country ~duration ~file_created_at ~id ~is_favorite ~is_image ~is_trashed ~live_photo_video_id ~local_offset_hours ~owner_id ~projection_type ~ratio ~thumbhash ~visibility ?latitude ?longitude ?stack () = { city; country; duration; file_created_at; id; is_favorite; is_image; is_trashed; latitude; live_photo_video_id; local_offset_hours; longitude; owner_id; projection_type; ratio; stack; thumbhash; visibility }
12893
12894 let city t = t.city
12895 let country t = t.country
12896 let duration t = t.duration
12897 let file_created_at t = t.file_created_at
12898 let id t = t.id
12899 let is_favorite t = t.is_favorite
12900 let is_image t = t.is_image
12901 let is_trashed t = t.is_trashed
12902 let latitude t = t.latitude
12903 let live_photo_video_id t = t.live_photo_video_id
12904 let local_offset_hours t = t.local_offset_hours
12905 let longitude t = t.longitude
12906 let owner_id t = t.owner_id
12907 let projection_type t = t.projection_type
12908 let ratio t = t.ratio
12909 let stack t = t.stack
12910 let thumbhash t = t.thumbhash
12911 let visibility t = t.visibility
12912
12913 let jsont : t Jsont.t =
12914 Jsont.Object.map ~kind:"TimeBucketAssetResponseDto"
12915 (fun city country duration file_created_at id is_favorite is_image is_trashed latitude live_photo_video_id local_offset_hours longitude owner_id projection_type ratio stack thumbhash visibility -> { city; country; duration; file_created_at; id; is_favorite; is_image; is_trashed; latitude; live_photo_video_id; local_offset_hours; longitude; owner_id; projection_type; ratio; stack; thumbhash; visibility })
12916 |> Jsont.Object.mem "city" (Jsont.list Jsont.string) ~enc:(fun r -> r.city)
12917 |> Jsont.Object.mem "country" (Jsont.list Jsont.string) ~enc:(fun r -> r.country)
12918 |> Jsont.Object.mem "duration" (Jsont.list Jsont.string) ~enc:(fun r -> r.duration)
12919 |> Jsont.Object.mem "fileCreatedAt" (Jsont.list Jsont.string) ~enc:(fun r -> r.file_created_at)
12920 |> Jsont.Object.mem "id" (Jsont.list Jsont.string) ~enc:(fun r -> r.id)
12921 |> Jsont.Object.mem "isFavorite" (Jsont.list Jsont.bool) ~enc:(fun r -> r.is_favorite)
12922 |> Jsont.Object.mem "isImage" (Jsont.list Jsont.bool) ~enc:(fun r -> r.is_image)
12923 |> Jsont.Object.mem "isTrashed" (Jsont.list Jsont.bool) ~enc:(fun r -> r.is_trashed)
12924 |> Jsont.Object.opt_mem "latitude" (Jsont.list Jsont.number) ~enc:(fun r -> r.latitude)
12925 |> Jsont.Object.mem "livePhotoVideoId" (Jsont.list Jsont.string) ~enc:(fun r -> r.live_photo_video_id)
12926 |> Jsont.Object.mem "localOffsetHours" (Jsont.list Jsont.number) ~enc:(fun r -> r.local_offset_hours)
12927 |> Jsont.Object.opt_mem "longitude" (Jsont.list Jsont.number) ~enc:(fun r -> r.longitude)
12928 |> Jsont.Object.mem "ownerId" (Jsont.list Jsont.string) ~enc:(fun r -> r.owner_id)
12929 |> Jsont.Object.mem "projectionType" (Jsont.list Jsont.string) ~enc:(fun r -> r.projection_type)
12930 |> Jsont.Object.mem "ratio" (Jsont.list Jsont.number) ~enc:(fun r -> r.ratio)
12931 |> Jsont.Object.opt_mem "stack" (Jsont.list (Jsont.list Jsont.string)) ~enc:(fun r -> r.stack)
12932 |> Jsont.Object.mem "thumbhash" (Jsont.list Jsont.string) ~enc:(fun r -> r.thumbhash)
12933 |> Jsont.Object.mem "visibility" (Jsont.list AssetVisibility.T.jsont) ~enc:(fun r -> r.visibility)
12934 |> Jsont.Object.skip_unknown
12935 |> Jsont.Object.finish
12936 end
12937
12938 (** Get time bucket
12939
12940 Retrieve a string of all asset ids in a given time bucket.
12941 @param album_id Filter assets belonging to a specific album
12942 @param is_favorite Filter by favorite status (true for favorites only, false for non-favorites only)
12943 @param is_trashed Filter by trash status (true for trashed assets only, false for non-trashed only)
12944 @param order Sort order for assets within time buckets (ASC for oldest first, DESC for newest first)
12945 @param person_id Filter assets containing a specific person (face recognition)
12946 @param tag_id Filter assets with a specific tag
12947 @param time_bucket Time bucket identifier in YYYY-MM-DD format (e.g., "2024-01-01" for January 2024)
12948 @param user_id Filter assets by specific user ID
12949 @param visibility Filter by asset visibility status (ARCHIVE, TIMELINE, HIDDEN, LOCKED)
12950 @param with_coordinates Include location data in the response
12951 @param with_partners Include assets shared by partners
12952 @param with_stacked Include stacked assets in the response. When true, only primary assets from stacks are returned.
12953 *)
12954 let get_time_bucket ?album_id ?is_favorite ?is_trashed ?key ?order ?person_id ?slug ?tag_id ~time_bucket ?user_id ?visibility ?with_coordinates ?with_partners ?with_stacked client () =
12955 let op_name = "get_time_bucket" in
12956 let url_path = "/timeline/bucket" in
12957 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"albumId" ~value:album_id; Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"order" ~value:order; Openapi.Runtime.Query.optional ~key:"personId" ~value:person_id; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug; Openapi.Runtime.Query.optional ~key:"tagId" ~value:tag_id; Openapi.Runtime.Query.singleton ~key:"timeBucket" ~value:time_bucket; Openapi.Runtime.Query.optional ~key:"userId" ~value:user_id; Openapi.Runtime.Query.optional ~key:"visibility" ~value:visibility; Openapi.Runtime.Query.optional ~key:"withCoordinates" ~value:with_coordinates; Openapi.Runtime.Query.optional ~key:"withPartners" ~value:with_partners; Openapi.Runtime.Query.optional ~key:"withStacked" ~value:with_stacked]) in
12958 let url = client.base_url ^ url_path ^ query in
12959 let response =
12960 try Requests.get client.session url
12961 with Eio.Io _ as ex ->
12962 let bt = Printexc.get_raw_backtrace () in
12963 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
12964 in
12965 if Requests.Response.ok response then
12966 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
12967 else
12968 let body = Requests.Response.text response in
12969 let parsed_body =
12970 match Jsont_bytesrw.decode_string Jsont.json body with
12971 | Ok json -> Some (Openapi.Runtime.Json json)
12972 | Error _ -> Some (Openapi.Runtime.Raw body)
12973 in
12974 raise (Openapi.Runtime.Api_error {
12975 operation = op_name;
12976 method_ = "GET";
12977 url;
12978 status = Requests.Response.status_code response;
12979 body;
12980 parsed_body;
12981 })
12982end
12983
12984module AssetBulk = struct
12985 module Types = struct
12986 module UpdateDto = struct
12987 type t = {
12988 date_time_original : string option;
12989 date_time_relative : float option;
12990 description : string option;
12991 duplicate_id : string option;
12992 ids : string list;
12993 is_favorite : bool option;
12994 latitude : float option;
12995 longitude : float option;
12996 rating : float option;
12997 time_zone : string option;
12998 visibility : AssetVisibility.T.t option;
12999 }
13000 end
13001 end
13002
13003 module UpdateDto = struct
13004 include Types.UpdateDto
13005
13006 let v ~ids ?date_time_original ?date_time_relative ?description ?duplicate_id ?is_favorite ?latitude ?longitude ?rating ?time_zone ?visibility () = { date_time_original; date_time_relative; description; duplicate_id; ids; is_favorite; latitude; longitude; rating; time_zone; visibility }
13007
13008 let date_time_original t = t.date_time_original
13009 let date_time_relative t = t.date_time_relative
13010 let description t = t.description
13011 let duplicate_id t = t.duplicate_id
13012 let ids t = t.ids
13013 let is_favorite t = t.is_favorite
13014 let latitude t = t.latitude
13015 let longitude t = t.longitude
13016 let rating t = t.rating
13017 let time_zone t = t.time_zone
13018 let visibility t = t.visibility
13019
13020 let jsont : t Jsont.t =
13021 Jsont.Object.map ~kind:"AssetBulkUpdateDto"
13022 (fun date_time_original date_time_relative description duplicate_id ids is_favorite latitude longitude rating time_zone visibility -> { date_time_original; date_time_relative; description; duplicate_id; ids; is_favorite; latitude; longitude; rating; time_zone; visibility })
13023 |> Jsont.Object.opt_mem "dateTimeOriginal" Jsont.string ~enc:(fun r -> r.date_time_original)
13024 |> Jsont.Object.opt_mem "dateTimeRelative" Jsont.number ~enc:(fun r -> r.date_time_relative)
13025 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
13026 |> Jsont.Object.mem "duplicateId" Openapi.Runtime.nullable_string
13027 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.duplicate_id)
13028 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
13029 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13030 |> Jsont.Object.opt_mem "latitude" Jsont.number ~enc:(fun r -> r.latitude)
13031 |> Jsont.Object.opt_mem "longitude" Jsont.number ~enc:(fun r -> r.longitude)
13032 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
13033 |> Jsont.Object.opt_mem "timeZone" Jsont.string ~enc:(fun r -> r.time_zone)
13034 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13035 |> Jsont.Object.skip_unknown
13036 |> Jsont.Object.finish
13037 end
13038end
13039
13040module AssetTypeEnum = struct
13041 module Types = struct
13042 module T = struct
13043 type t = [
13044 | `Image
13045 | `Video
13046 | `Audio
13047 | `Other
13048 ]
13049 end
13050 end
13051
13052 module T = struct
13053 include Types.T
13054
13055 let jsont : t Jsont.t =
13056 Jsont.map Jsont.string ~kind:"AssetTypeEnum"
13057 ~dec:(function
13058 | "IMAGE" -> `Image
13059 | "VIDEO" -> `Video
13060 | "AUDIO" -> `Audio
13061 | "OTHER" -> `Other
13062 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
13063 ~enc:(function
13064 | `Image -> "IMAGE"
13065 | `Video -> "VIDEO"
13066 | `Audio -> "AUDIO"
13067 | `Other -> "OTHER")
13068 end
13069end
13070
13071module SyncAssetV1 = struct
13072 module Types = struct
13073 module T = struct
13074 type t = {
13075 checksum : string;
13076 deleted_at : Ptime.t option;
13077 duration : string option;
13078 file_created_at : Ptime.t option;
13079 file_modified_at : Ptime.t option;
13080 height : int option;
13081 id : string;
13082 is_edited : bool;
13083 is_favorite : bool;
13084 library_id : string option;
13085 live_photo_video_id : string option;
13086 local_date_time : Ptime.t option;
13087 original_file_name : string;
13088 owner_id : string;
13089 stack_id : string option;
13090 thumbhash : string option;
13091 type_ : AssetTypeEnum.T.t;
13092 visibility : AssetVisibility.T.t;
13093 width : int option;
13094 }
13095 end
13096 end
13097
13098 module T = struct
13099 include Types.T
13100
13101 let v ~checksum ~id ~is_edited ~is_favorite ~original_file_name ~owner_id ~type_ ~visibility ?deleted_at ?duration ?file_created_at ?file_modified_at ?height ?library_id ?live_photo_video_id ?local_date_time ?stack_id ?thumbhash ?width () = { checksum; deleted_at; duration; file_created_at; file_modified_at; height; id; is_edited; is_favorite; library_id; live_photo_video_id; local_date_time; original_file_name; owner_id; stack_id; thumbhash; type_; visibility; width }
13102
13103 let checksum t = t.checksum
13104 let deleted_at t = t.deleted_at
13105 let duration t = t.duration
13106 let file_created_at t = t.file_created_at
13107 let file_modified_at t = t.file_modified_at
13108 let height t = t.height
13109 let id t = t.id
13110 let is_edited t = t.is_edited
13111 let is_favorite t = t.is_favorite
13112 let library_id t = t.library_id
13113 let live_photo_video_id t = t.live_photo_video_id
13114 let local_date_time t = t.local_date_time
13115 let original_file_name t = t.original_file_name
13116 let owner_id t = t.owner_id
13117 let stack_id t = t.stack_id
13118 let thumbhash t = t.thumbhash
13119 let type_ t = t.type_
13120 let visibility t = t.visibility
13121 let width t = t.width
13122
13123 let jsont : t Jsont.t =
13124 Jsont.Object.map ~kind:"SyncAssetV1"
13125 (fun checksum deleted_at duration file_created_at file_modified_at height id is_edited is_favorite library_id live_photo_video_id local_date_time original_file_name owner_id stack_id thumbhash type_ visibility width -> { checksum; deleted_at; duration; file_created_at; file_modified_at; height; id; is_edited; is_favorite; library_id; live_photo_video_id; local_date_time; original_file_name; owner_id; stack_id; thumbhash; type_; visibility; width })
13126 |> Jsont.Object.mem "checksum" Jsont.string ~enc:(fun r -> r.checksum)
13127 |> Jsont.Object.mem "deletedAt" Openapi.Runtime.nullable_ptime
13128 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.deleted_at)
13129 |> Jsont.Object.mem "duration" Openapi.Runtime.nullable_string
13130 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.duration)
13131 |> Jsont.Object.mem "fileCreatedAt" Openapi.Runtime.nullable_ptime
13132 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.file_created_at)
13133 |> Jsont.Object.mem "fileModifiedAt" Openapi.Runtime.nullable_ptime
13134 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.file_modified_at)
13135 |> Jsont.Object.mem "height" Openapi.Runtime.nullable_int
13136 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.height)
13137 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
13138 |> Jsont.Object.mem "isEdited" Jsont.bool ~enc:(fun r -> r.is_edited)
13139 |> Jsont.Object.mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13140 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
13141 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
13142 |> Jsont.Object.mem "livePhotoVideoId" Openapi.Runtime.nullable_string
13143 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.live_photo_video_id)
13144 |> Jsont.Object.mem "localDateTime" Openapi.Runtime.nullable_ptime
13145 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.local_date_time)
13146 |> Jsont.Object.mem "originalFileName" Jsont.string ~enc:(fun r -> r.original_file_name)
13147 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
13148 |> Jsont.Object.mem "stackId" Openapi.Runtime.nullable_string
13149 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.stack_id)
13150 |> Jsont.Object.mem "thumbhash" Openapi.Runtime.nullable_string
13151 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.thumbhash)
13152 |> Jsont.Object.mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
13153 |> Jsont.Object.mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13154 |> Jsont.Object.mem "width" Openapi.Runtime.nullable_int
13155 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.width)
13156 |> Jsont.Object.skip_unknown
13157 |> Jsont.Object.finish
13158 end
13159end
13160
13161module StatisticsSearch = struct
13162 module Types = struct
13163 module Dto = struct
13164 type t = {
13165 album_ids : string list option;
13166 city : string option;
13167 country : string option;
13168 created_after : Ptime.t option;
13169 created_before : Ptime.t option;
13170 description : string option;
13171 device_id : string option;
13172 is_encoded : bool option;
13173 is_favorite : bool option;
13174 is_motion : bool option;
13175 is_not_in_album : bool option;
13176 is_offline : bool option;
13177 lens_model : string option;
13178 library_id : string option;
13179 make : string option;
13180 model : string option;
13181 ocr : string option;
13182 person_ids : string list option;
13183 rating : float option;
13184 state : string option;
13185 tag_ids : string list option;
13186 taken_after : Ptime.t option;
13187 taken_before : Ptime.t option;
13188 trashed_after : Ptime.t option;
13189 trashed_before : Ptime.t option;
13190 type_ : AssetTypeEnum.T.t option;
13191 updated_after : Ptime.t option;
13192 updated_before : Ptime.t option;
13193 visibility : AssetVisibility.T.t option;
13194 }
13195 end
13196 end
13197
13198 module Dto = struct
13199 include Types.Dto
13200
13201 let v ?album_ids ?city ?country ?created_after ?created_before ?description ?device_id ?is_encoded ?is_favorite ?is_motion ?is_not_in_album ?is_offline ?lens_model ?library_id ?make ?model ?ocr ?person_ids ?rating ?state ?tag_ids ?taken_after ?taken_before ?trashed_after ?trashed_before ?type_ ?updated_after ?updated_before ?visibility () = { album_ids; city; country; created_after; created_before; description; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; person_ids; rating; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility }
13202
13203 let album_ids t = t.album_ids
13204 let city t = t.city
13205 let country t = t.country
13206 let created_after t = t.created_after
13207 let created_before t = t.created_before
13208 let description t = t.description
13209 let device_id t = t.device_id
13210 let is_encoded t = t.is_encoded
13211 let is_favorite t = t.is_favorite
13212 let is_motion t = t.is_motion
13213 let is_not_in_album t = t.is_not_in_album
13214 let is_offline t = t.is_offline
13215 let lens_model t = t.lens_model
13216 let library_id t = t.library_id
13217 let make t = t.make
13218 let model t = t.model
13219 let ocr t = t.ocr
13220 let person_ids t = t.person_ids
13221 let rating t = t.rating
13222 let state t = t.state
13223 let tag_ids t = t.tag_ids
13224 let taken_after t = t.taken_after
13225 let taken_before t = t.taken_before
13226 let trashed_after t = t.trashed_after
13227 let trashed_before t = t.trashed_before
13228 let type_ t = t.type_
13229 let updated_after t = t.updated_after
13230 let updated_before t = t.updated_before
13231 let visibility t = t.visibility
13232
13233 let jsont : t Jsont.t =
13234 Jsont.Object.map ~kind:"StatisticsSearchDto"
13235 (fun album_ids city country created_after created_before description device_id is_encoded is_favorite is_motion is_not_in_album is_offline lens_model library_id make model ocr person_ids rating state tag_ids taken_after taken_before trashed_after trashed_before type_ updated_after updated_before visibility -> { album_ids; city; country; created_after; created_before; description; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; person_ids; rating; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility })
13236 |> Jsont.Object.opt_mem "albumIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.album_ids)
13237 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
13238 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
13239 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
13240 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
13241 |> Jsont.Object.opt_mem "createdAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_after)
13242 |> Jsont.Object.opt_mem "createdBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_before)
13243 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
13244 |> Jsont.Object.opt_mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
13245 |> Jsont.Object.opt_mem "isEncoded" Jsont.bool ~enc:(fun r -> r.is_encoded)
13246 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13247 |> Jsont.Object.opt_mem "isMotion" Jsont.bool ~enc:(fun r -> r.is_motion)
13248 |> Jsont.Object.opt_mem "isNotInAlbum" Jsont.bool ~enc:(fun r -> r.is_not_in_album)
13249 |> Jsont.Object.opt_mem "isOffline" Jsont.bool ~enc:(fun r -> r.is_offline)
13250 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
13251 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
13252 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
13253 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
13254 |> Jsont.Object.opt_mem "make" Jsont.string ~enc:(fun r -> r.make)
13255 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
13256 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
13257 |> Jsont.Object.opt_mem "ocr" Jsont.string ~enc:(fun r -> r.ocr)
13258 |> Jsont.Object.opt_mem "personIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.person_ids)
13259 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
13260 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
13261 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
13262 |> Jsont.Object.mem "tagIds" (Openapi.Runtime.nullable_any (Jsont.list Jsont.string))
13263 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.tag_ids)
13264 |> Jsont.Object.opt_mem "takenAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_after)
13265 |> Jsont.Object.opt_mem "takenBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_before)
13266 |> Jsont.Object.opt_mem "trashedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_after)
13267 |> Jsont.Object.opt_mem "trashedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_before)
13268 |> Jsont.Object.opt_mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
13269 |> Jsont.Object.opt_mem "updatedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_after)
13270 |> Jsont.Object.opt_mem "updatedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_before)
13271 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13272 |> Jsont.Object.skip_unknown
13273 |> Jsont.Object.finish
13274 end
13275end
13276
13277module SearchStatistics = struct
13278 module Types = struct
13279 module ResponseDto = struct
13280 type t = {
13281 total : int;
13282 }
13283 end
13284 end
13285
13286 module ResponseDto = struct
13287 include Types.ResponseDto
13288
13289 let v ~total () = { total }
13290
13291 let total t = t.total
13292
13293 let jsont : t Jsont.t =
13294 Jsont.Object.map ~kind:"SearchStatisticsResponseDto"
13295 (fun total -> { total })
13296 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
13297 |> Jsont.Object.skip_unknown
13298 |> Jsont.Object.finish
13299 end
13300
13301 (** Search asset statistics
13302
13303 Retrieve statistical data about assets based on search criteria, such as the total matching count. *)
13304 let search_asset_statistics ~body client () =
13305 let op_name = "search_asset_statistics" in
13306 let url_path = "/search/statistics" in
13307 let query = "" in
13308 let url = client.base_url ^ url_path ^ query in
13309 let response =
13310 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json StatisticsSearch.Dto.jsont body)) url
13311 with Eio.Io _ as ex ->
13312 let bt = Printexc.get_raw_backtrace () in
13313 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
13314 in
13315 if Requests.Response.ok response then
13316 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
13317 else
13318 let body = Requests.Response.text response in
13319 let parsed_body =
13320 match Jsont_bytesrw.decode_string Jsont.json body with
13321 | Ok json -> Some (Openapi.Runtime.Json json)
13322 | Error _ -> Some (Openapi.Runtime.Raw body)
13323 in
13324 raise (Openapi.Runtime.Api_error {
13325 operation = op_name;
13326 method_ = "POST";
13327 url;
13328 status = Requests.Response.status_code response;
13329 body;
13330 parsed_body;
13331 })
13332end
13333
13334module SmartSearch = struct
13335 module Types = struct
13336 module Dto = struct
13337 type t = {
13338 album_ids : string list option;
13339 city : string option;
13340 country : string option;
13341 created_after : Ptime.t option;
13342 created_before : Ptime.t option;
13343 device_id : string option;
13344 is_encoded : bool option;
13345 is_favorite : bool option;
13346 is_motion : bool option;
13347 is_not_in_album : bool option;
13348 is_offline : bool option;
13349 language : string option;
13350 lens_model : string option;
13351 library_id : string option;
13352 make : string option;
13353 model : string option;
13354 ocr : string option;
13355 page : float option;
13356 person_ids : string list option;
13357 query : string option;
13358 query_asset_id : string option;
13359 rating : float option;
13360 size : float option;
13361 state : string option;
13362 tag_ids : string list option;
13363 taken_after : Ptime.t option;
13364 taken_before : Ptime.t option;
13365 trashed_after : Ptime.t option;
13366 trashed_before : Ptime.t option;
13367 type_ : AssetTypeEnum.T.t option;
13368 updated_after : Ptime.t option;
13369 updated_before : Ptime.t option;
13370 visibility : AssetVisibility.T.t option;
13371 with_deleted : bool option;
13372 with_exif : bool option;
13373 }
13374 end
13375 end
13376
13377 module Dto = struct
13378 include Types.Dto
13379
13380 let v ?album_ids ?city ?country ?created_after ?created_before ?device_id ?is_encoded ?is_favorite ?is_motion ?is_not_in_album ?is_offline ?language ?lens_model ?library_id ?make ?model ?ocr ?page ?person_ids ?query ?query_asset_id ?rating ?size ?state ?tag_ids ?taken_after ?taken_before ?trashed_after ?trashed_before ?type_ ?updated_after ?updated_before ?visibility ?with_deleted ?with_exif () = { album_ids; city; country; created_after; created_before; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; language; lens_model; library_id; make; model; ocr; page; person_ids; query; query_asset_id; rating; size; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif }
13381
13382 let album_ids t = t.album_ids
13383 let city t = t.city
13384 let country t = t.country
13385 let created_after t = t.created_after
13386 let created_before t = t.created_before
13387 let device_id t = t.device_id
13388 let is_encoded t = t.is_encoded
13389 let is_favorite t = t.is_favorite
13390 let is_motion t = t.is_motion
13391 let is_not_in_album t = t.is_not_in_album
13392 let is_offline t = t.is_offline
13393 let language t = t.language
13394 let lens_model t = t.lens_model
13395 let library_id t = t.library_id
13396 let make t = t.make
13397 let model t = t.model
13398 let ocr t = t.ocr
13399 let page t = t.page
13400 let person_ids t = t.person_ids
13401 let query t = t.query
13402 let query_asset_id t = t.query_asset_id
13403 let rating t = t.rating
13404 let size t = t.size
13405 let state t = t.state
13406 let tag_ids t = t.tag_ids
13407 let taken_after t = t.taken_after
13408 let taken_before t = t.taken_before
13409 let trashed_after t = t.trashed_after
13410 let trashed_before t = t.trashed_before
13411 let type_ t = t.type_
13412 let updated_after t = t.updated_after
13413 let updated_before t = t.updated_before
13414 let visibility t = t.visibility
13415 let with_deleted t = t.with_deleted
13416 let with_exif t = t.with_exif
13417
13418 let jsont : t Jsont.t =
13419 Jsont.Object.map ~kind:"SmartSearchDto"
13420 (fun album_ids city country created_after created_before device_id is_encoded is_favorite is_motion is_not_in_album is_offline language lens_model library_id make model ocr page person_ids query query_asset_id rating size state tag_ids taken_after taken_before trashed_after trashed_before type_ updated_after updated_before visibility with_deleted with_exif -> { album_ids; city; country; created_after; created_before; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; language; lens_model; library_id; make; model; ocr; page; person_ids; query; query_asset_id; rating; size; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif })
13421 |> Jsont.Object.opt_mem "albumIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.album_ids)
13422 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
13423 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
13424 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
13425 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
13426 |> Jsont.Object.opt_mem "createdAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_after)
13427 |> Jsont.Object.opt_mem "createdBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_before)
13428 |> Jsont.Object.opt_mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
13429 |> Jsont.Object.opt_mem "isEncoded" Jsont.bool ~enc:(fun r -> r.is_encoded)
13430 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13431 |> Jsont.Object.opt_mem "isMotion" Jsont.bool ~enc:(fun r -> r.is_motion)
13432 |> Jsont.Object.opt_mem "isNotInAlbum" Jsont.bool ~enc:(fun r -> r.is_not_in_album)
13433 |> Jsont.Object.opt_mem "isOffline" Jsont.bool ~enc:(fun r -> r.is_offline)
13434 |> Jsont.Object.opt_mem "language" Jsont.string ~enc:(fun r -> r.language)
13435 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
13436 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
13437 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
13438 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
13439 |> Jsont.Object.opt_mem "make" Jsont.string ~enc:(fun r -> r.make)
13440 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
13441 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
13442 |> Jsont.Object.opt_mem "ocr" Jsont.string ~enc:(fun r -> r.ocr)
13443 |> Jsont.Object.opt_mem "page" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.page)
13444 |> Jsont.Object.opt_mem "personIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.person_ids)
13445 |> Jsont.Object.opt_mem "query" Jsont.string ~enc:(fun r -> r.query)
13446 |> Jsont.Object.opt_mem "queryAssetId" Jsont.string ~enc:(fun r -> r.query_asset_id)
13447 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
13448 |> Jsont.Object.opt_mem "size" (Openapi.Runtime.validated_float ~minimum:1. ~maximum:1000. Jsont.number) ~enc:(fun r -> r.size)
13449 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
13450 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
13451 |> Jsont.Object.mem "tagIds" (Openapi.Runtime.nullable_any (Jsont.list Jsont.string))
13452 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.tag_ids)
13453 |> Jsont.Object.opt_mem "takenAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_after)
13454 |> Jsont.Object.opt_mem "takenBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_before)
13455 |> Jsont.Object.opt_mem "trashedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_after)
13456 |> Jsont.Object.opt_mem "trashedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_before)
13457 |> Jsont.Object.opt_mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
13458 |> Jsont.Object.opt_mem "updatedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_after)
13459 |> Jsont.Object.opt_mem "updatedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_before)
13460 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13461 |> Jsont.Object.opt_mem "withDeleted" Jsont.bool ~enc:(fun r -> r.with_deleted)
13462 |> Jsont.Object.opt_mem "withExif" Jsont.bool ~enc:(fun r -> r.with_exif)
13463 |> Jsont.Object.skip_unknown
13464 |> Jsont.Object.finish
13465 end
13466end
13467
13468module RandomSearch = struct
13469 module Types = struct
13470 module Dto = struct
13471 type t = {
13472 album_ids : string list option;
13473 city : string option;
13474 country : string option;
13475 created_after : Ptime.t option;
13476 created_before : Ptime.t option;
13477 device_id : string option;
13478 is_encoded : bool option;
13479 is_favorite : bool option;
13480 is_motion : bool option;
13481 is_not_in_album : bool option;
13482 is_offline : bool option;
13483 lens_model : string option;
13484 library_id : string option;
13485 make : string option;
13486 model : string option;
13487 ocr : string option;
13488 person_ids : string list option;
13489 rating : float option;
13490 size : float option;
13491 state : string option;
13492 tag_ids : string list option;
13493 taken_after : Ptime.t option;
13494 taken_before : Ptime.t option;
13495 trashed_after : Ptime.t option;
13496 trashed_before : Ptime.t option;
13497 type_ : AssetTypeEnum.T.t option;
13498 updated_after : Ptime.t option;
13499 updated_before : Ptime.t option;
13500 visibility : AssetVisibility.T.t option;
13501 with_deleted : bool option;
13502 with_exif : bool option;
13503 with_people : bool option;
13504 with_stacked : bool option;
13505 }
13506 end
13507 end
13508
13509 module Dto = struct
13510 include Types.Dto
13511
13512 let v ?album_ids ?city ?country ?created_after ?created_before ?device_id ?is_encoded ?is_favorite ?is_motion ?is_not_in_album ?is_offline ?lens_model ?library_id ?make ?model ?ocr ?person_ids ?rating ?size ?state ?tag_ids ?taken_after ?taken_before ?trashed_after ?trashed_before ?type_ ?updated_after ?updated_before ?visibility ?with_deleted ?with_exif ?with_people ?with_stacked () = { album_ids; city; country; created_after; created_before; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; person_ids; rating; size; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif; with_people; with_stacked }
13513
13514 let album_ids t = t.album_ids
13515 let city t = t.city
13516 let country t = t.country
13517 let created_after t = t.created_after
13518 let created_before t = t.created_before
13519 let device_id t = t.device_id
13520 let is_encoded t = t.is_encoded
13521 let is_favorite t = t.is_favorite
13522 let is_motion t = t.is_motion
13523 let is_not_in_album t = t.is_not_in_album
13524 let is_offline t = t.is_offline
13525 let lens_model t = t.lens_model
13526 let library_id t = t.library_id
13527 let make t = t.make
13528 let model t = t.model
13529 let ocr t = t.ocr
13530 let person_ids t = t.person_ids
13531 let rating t = t.rating
13532 let size t = t.size
13533 let state t = t.state
13534 let tag_ids t = t.tag_ids
13535 let taken_after t = t.taken_after
13536 let taken_before t = t.taken_before
13537 let trashed_after t = t.trashed_after
13538 let trashed_before t = t.trashed_before
13539 let type_ t = t.type_
13540 let updated_after t = t.updated_after
13541 let updated_before t = t.updated_before
13542 let visibility t = t.visibility
13543 let with_deleted t = t.with_deleted
13544 let with_exif t = t.with_exif
13545 let with_people t = t.with_people
13546 let with_stacked t = t.with_stacked
13547
13548 let jsont : t Jsont.t =
13549 Jsont.Object.map ~kind:"RandomSearchDto"
13550 (fun album_ids city country created_after created_before device_id is_encoded is_favorite is_motion is_not_in_album is_offline lens_model library_id make model ocr person_ids rating size state tag_ids taken_after taken_before trashed_after trashed_before type_ updated_after updated_before visibility with_deleted with_exif with_people with_stacked -> { album_ids; city; country; created_after; created_before; device_id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; person_ids; rating; size; state; tag_ids; taken_after; taken_before; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif; with_people; with_stacked })
13551 |> Jsont.Object.opt_mem "albumIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.album_ids)
13552 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
13553 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
13554 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
13555 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
13556 |> Jsont.Object.opt_mem "createdAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_after)
13557 |> Jsont.Object.opt_mem "createdBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_before)
13558 |> Jsont.Object.opt_mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
13559 |> Jsont.Object.opt_mem "isEncoded" Jsont.bool ~enc:(fun r -> r.is_encoded)
13560 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13561 |> Jsont.Object.opt_mem "isMotion" Jsont.bool ~enc:(fun r -> r.is_motion)
13562 |> Jsont.Object.opt_mem "isNotInAlbum" Jsont.bool ~enc:(fun r -> r.is_not_in_album)
13563 |> Jsont.Object.opt_mem "isOffline" Jsont.bool ~enc:(fun r -> r.is_offline)
13564 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
13565 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
13566 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
13567 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
13568 |> Jsont.Object.opt_mem "make" Jsont.string ~enc:(fun r -> r.make)
13569 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
13570 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
13571 |> Jsont.Object.opt_mem "ocr" Jsont.string ~enc:(fun r -> r.ocr)
13572 |> Jsont.Object.opt_mem "personIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.person_ids)
13573 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
13574 |> Jsont.Object.opt_mem "size" (Openapi.Runtime.validated_float ~minimum:1. ~maximum:1000. Jsont.number) ~enc:(fun r -> r.size)
13575 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
13576 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
13577 |> Jsont.Object.mem "tagIds" (Openapi.Runtime.nullable_any (Jsont.list Jsont.string))
13578 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.tag_ids)
13579 |> Jsont.Object.opt_mem "takenAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_after)
13580 |> Jsont.Object.opt_mem "takenBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_before)
13581 |> Jsont.Object.opt_mem "trashedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_after)
13582 |> Jsont.Object.opt_mem "trashedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_before)
13583 |> Jsont.Object.opt_mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
13584 |> Jsont.Object.opt_mem "updatedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_after)
13585 |> Jsont.Object.opt_mem "updatedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_before)
13586 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13587 |> Jsont.Object.opt_mem "withDeleted" Jsont.bool ~enc:(fun r -> r.with_deleted)
13588 |> Jsont.Object.opt_mem "withExif" Jsont.bool ~enc:(fun r -> r.with_exif)
13589 |> Jsont.Object.opt_mem "withPeople" Jsont.bool ~enc:(fun r -> r.with_people)
13590 |> Jsont.Object.opt_mem "withStacked" Jsont.bool ~enc:(fun r -> r.with_stacked)
13591 |> Jsont.Object.skip_unknown
13592 |> Jsont.Object.finish
13593 end
13594end
13595
13596module AssetStats = struct
13597 module Types = struct
13598 module ResponseDto = struct
13599 type t = {
13600 images : int;
13601 total : int;
13602 videos : int;
13603 }
13604 end
13605 end
13606
13607 module ResponseDto = struct
13608 include Types.ResponseDto
13609
13610 let v ~images ~total ~videos () = { images; total; videos }
13611
13612 let images t = t.images
13613 let total t = t.total
13614 let videos t = t.videos
13615
13616 let jsont : t Jsont.t =
13617 Jsont.Object.map ~kind:"AssetStatsResponseDto"
13618 (fun images total videos -> { images; total; videos })
13619 |> Jsont.Object.mem "images" Jsont.int ~enc:(fun r -> r.images)
13620 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
13621 |> Jsont.Object.mem "videos" Jsont.int ~enc:(fun r -> r.videos)
13622 |> Jsont.Object.skip_unknown
13623 |> Jsont.Object.finish
13624 end
13625
13626 (** Retrieve user statistics
13627
13628 Retrieve asset statistics for a specific user. *)
13629 let get_user_statistics_admin ~id ?is_favorite ?is_trashed ?visibility client () =
13630 let op_name = "get_user_statistics_admin" in
13631 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}/statistics" in
13632 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"visibility" ~value:visibility]) in
13633 let url = client.base_url ^ url_path ^ query in
13634 let response =
13635 try Requests.get client.session url
13636 with Eio.Io _ as ex ->
13637 let bt = Printexc.get_raw_backtrace () in
13638 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
13639 in
13640 if Requests.Response.ok response then
13641 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
13642 else
13643 let body = Requests.Response.text response in
13644 let parsed_body =
13645 match Jsont_bytesrw.decode_string Jsont.json body with
13646 | Ok json -> Some (Openapi.Runtime.Json json)
13647 | Error _ -> Some (Openapi.Runtime.Raw body)
13648 in
13649 raise (Openapi.Runtime.Api_error {
13650 operation = op_name;
13651 method_ = "GET";
13652 url;
13653 status = Requests.Response.status_code response;
13654 body;
13655 parsed_body;
13656 })
13657
13658 (** Get asset statistics
13659
13660 Retrieve various statistics about the assets owned by the authenticated user. *)
13661 let get_asset_statistics ?is_favorite ?is_trashed ?visibility client () =
13662 let op_name = "get_asset_statistics" in
13663 let url_path = "/assets/statistics" in
13664 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"visibility" ~value:visibility]) in
13665 let url = client.base_url ^ url_path ^ query in
13666 let response =
13667 try Requests.get client.session url
13668 with Eio.Io _ as ex ->
13669 let bt = Printexc.get_raw_backtrace () in
13670 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
13671 in
13672 if Requests.Response.ok response then
13673 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
13674 else
13675 let body = Requests.Response.text response in
13676 let parsed_body =
13677 match Jsont_bytesrw.decode_string Jsont.json body with
13678 | Ok json -> Some (Openapi.Runtime.Json json)
13679 | Error _ -> Some (Openapi.Runtime.Raw body)
13680 in
13681 raise (Openapi.Runtime.Api_error {
13682 operation = op_name;
13683 method_ = "GET";
13684 url;
13685 status = Requests.Response.status_code response;
13686 body;
13687 parsed_body;
13688 })
13689end
13690
13691module AssetStack = struct
13692 module Types = struct
13693 module ResponseDto = struct
13694 type t = {
13695 asset_count : int;
13696 id : string;
13697 primary_asset_id : string;
13698 }
13699 end
13700 end
13701
13702 module ResponseDto = struct
13703 include Types.ResponseDto
13704
13705 let v ~asset_count ~id ~primary_asset_id () = { asset_count; id; primary_asset_id }
13706
13707 let asset_count t = t.asset_count
13708 let id t = t.id
13709 let primary_asset_id t = t.primary_asset_id
13710
13711 let jsont : t Jsont.t =
13712 Jsont.Object.map ~kind:"AssetStackResponseDto"
13713 (fun asset_count id primary_asset_id -> { asset_count; id; primary_asset_id })
13714 |> Jsont.Object.mem "assetCount" Jsont.int ~enc:(fun r -> r.asset_count)
13715 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
13716 |> Jsont.Object.mem "primaryAssetId" Jsont.string ~enc:(fun r -> r.primary_asset_id)
13717 |> Jsont.Object.skip_unknown
13718 |> Jsont.Object.finish
13719 end
13720end
13721
13722module AssetOrder = struct
13723 module Types = struct
13724 module T = struct
13725 type t = [
13726 | `Asc
13727 | `Desc
13728 ]
13729 end
13730 end
13731
13732 module T = struct
13733 include Types.T
13734
13735 let jsont : t Jsont.t =
13736 Jsont.map Jsont.string ~kind:"AssetOrder"
13737 ~dec:(function
13738 | "asc" -> `Asc
13739 | "desc" -> `Desc
13740 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
13741 ~enc:(function
13742 | `Asc -> "asc"
13743 | `Desc -> "desc")
13744 end
13745end
13746
13747module UpdateAlbum = struct
13748 module Types = struct
13749 module Dto = struct
13750 type t = {
13751 album_name : string option;
13752 album_thumbnail_asset_id : string option;
13753 description : string option;
13754 is_activity_enabled : bool option;
13755 order : AssetOrder.T.t option;
13756 }
13757 end
13758 end
13759
13760 module Dto = struct
13761 include Types.Dto
13762
13763 let v ?album_name ?album_thumbnail_asset_id ?description ?is_activity_enabled ?order () = { album_name; album_thumbnail_asset_id; description; is_activity_enabled; order }
13764
13765 let album_name t = t.album_name
13766 let album_thumbnail_asset_id t = t.album_thumbnail_asset_id
13767 let description t = t.description
13768 let is_activity_enabled t = t.is_activity_enabled
13769 let order t = t.order
13770
13771 let jsont : t Jsont.t =
13772 Jsont.Object.map ~kind:"UpdateAlbumDto"
13773 (fun album_name album_thumbnail_asset_id description is_activity_enabled order -> { album_name; album_thumbnail_asset_id; description; is_activity_enabled; order })
13774 |> Jsont.Object.opt_mem "albumName" Jsont.string ~enc:(fun r -> r.album_name)
13775 |> Jsont.Object.opt_mem "albumThumbnailAssetId" Jsont.string ~enc:(fun r -> r.album_thumbnail_asset_id)
13776 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
13777 |> Jsont.Object.opt_mem "isActivityEnabled" Jsont.bool ~enc:(fun r -> r.is_activity_enabled)
13778 |> Jsont.Object.opt_mem "order" AssetOrder.T.jsont ~enc:(fun r -> r.order)
13779 |> Jsont.Object.skip_unknown
13780 |> Jsont.Object.finish
13781 end
13782end
13783
13784module SyncAlbumV1 = struct
13785 module Types = struct
13786 module T = struct
13787 type t = {
13788 created_at : Ptime.t;
13789 description : string;
13790 id : string;
13791 is_activity_enabled : bool;
13792 name : string;
13793 order : AssetOrder.T.t;
13794 owner_id : string;
13795 thumbnail_asset_id : string option;
13796 updated_at : Ptime.t;
13797 }
13798 end
13799 end
13800
13801 module T = struct
13802 include Types.T
13803
13804 let v ~created_at ~description ~id ~is_activity_enabled ~name ~order ~owner_id ~updated_at ?thumbnail_asset_id () = { created_at; description; id; is_activity_enabled; name; order; owner_id; thumbnail_asset_id; updated_at }
13805
13806 let created_at t = t.created_at
13807 let description t = t.description
13808 let id t = t.id
13809 let is_activity_enabled t = t.is_activity_enabled
13810 let name t = t.name
13811 let order t = t.order
13812 let owner_id t = t.owner_id
13813 let thumbnail_asset_id t = t.thumbnail_asset_id
13814 let updated_at t = t.updated_at
13815
13816 let jsont : t Jsont.t =
13817 Jsont.Object.map ~kind:"SyncAlbumV1"
13818 (fun created_at description id is_activity_enabled name order owner_id thumbnail_asset_id updated_at -> { created_at; description; id; is_activity_enabled; name; order; owner_id; thumbnail_asset_id; updated_at })
13819 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
13820 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
13821 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
13822 |> Jsont.Object.mem "isActivityEnabled" Jsont.bool ~enc:(fun r -> r.is_activity_enabled)
13823 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
13824 |> Jsont.Object.mem "order" AssetOrder.T.jsont ~enc:(fun r -> r.order)
13825 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
13826 |> Jsont.Object.mem "thumbnailAssetId" Openapi.Runtime.nullable_string
13827 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.thumbnail_asset_id)
13828 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
13829 |> Jsont.Object.skip_unknown
13830 |> Jsont.Object.finish
13831 end
13832end
13833
13834module MetadataSearch = struct
13835 module Types = struct
13836 module Dto = struct
13837 type t = {
13838 album_ids : string list option;
13839 checksum : string option;
13840 city : string option;
13841 country : string option;
13842 created_after : Ptime.t option;
13843 created_before : Ptime.t option;
13844 description : string option;
13845 device_asset_id : string option;
13846 device_id : string option;
13847 encoded_video_path : string option;
13848 id : string option;
13849 is_encoded : bool option;
13850 is_favorite : bool option;
13851 is_motion : bool option;
13852 is_not_in_album : bool option;
13853 is_offline : bool option;
13854 lens_model : string option;
13855 library_id : string option;
13856 make : string option;
13857 model : string option;
13858 ocr : string option;
13859 order : AssetOrder.T.t;
13860 original_file_name : string option;
13861 original_path : string option;
13862 page : float option;
13863 person_ids : string list option;
13864 preview_path : string option;
13865 rating : float option;
13866 size : float option;
13867 state : string option;
13868 tag_ids : string list option;
13869 taken_after : Ptime.t option;
13870 taken_before : Ptime.t option;
13871 thumbnail_path : string option;
13872 trashed_after : Ptime.t option;
13873 trashed_before : Ptime.t option;
13874 type_ : AssetTypeEnum.T.t option;
13875 updated_after : Ptime.t option;
13876 updated_before : Ptime.t option;
13877 visibility : AssetVisibility.T.t option;
13878 with_deleted : bool option;
13879 with_exif : bool option;
13880 with_people : bool option;
13881 with_stacked : bool option;
13882 }
13883 end
13884 end
13885
13886 module Dto = struct
13887 include Types.Dto
13888
13889 let v ?(order=`Desc) ?album_ids ?checksum ?city ?country ?created_after ?created_before ?description ?device_asset_id ?device_id ?encoded_video_path ?id ?is_encoded ?is_favorite ?is_motion ?is_not_in_album ?is_offline ?lens_model ?library_id ?make ?model ?ocr ?original_file_name ?original_path ?page ?person_ids ?preview_path ?rating ?size ?state ?tag_ids ?taken_after ?taken_before ?thumbnail_path ?trashed_after ?trashed_before ?type_ ?updated_after ?updated_before ?visibility ?with_deleted ?with_exif ?with_people ?with_stacked () = { album_ids; checksum; city; country; created_after; created_before; description; device_asset_id; device_id; encoded_video_path; id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; order; original_file_name; original_path; page; person_ids; preview_path; rating; size; state; tag_ids; taken_after; taken_before; thumbnail_path; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif; with_people; with_stacked }
13890
13891 let album_ids t = t.album_ids
13892 let checksum t = t.checksum
13893 let city t = t.city
13894 let country t = t.country
13895 let created_after t = t.created_after
13896 let created_before t = t.created_before
13897 let description t = t.description
13898 let device_asset_id t = t.device_asset_id
13899 let device_id t = t.device_id
13900 let encoded_video_path t = t.encoded_video_path
13901 let id t = t.id
13902 let is_encoded t = t.is_encoded
13903 let is_favorite t = t.is_favorite
13904 let is_motion t = t.is_motion
13905 let is_not_in_album t = t.is_not_in_album
13906 let is_offline t = t.is_offline
13907 let lens_model t = t.lens_model
13908 let library_id t = t.library_id
13909 let make t = t.make
13910 let model t = t.model
13911 let ocr t = t.ocr
13912 let order t = t.order
13913 let original_file_name t = t.original_file_name
13914 let original_path t = t.original_path
13915 let page t = t.page
13916 let person_ids t = t.person_ids
13917 let preview_path t = t.preview_path
13918 let rating t = t.rating
13919 let size t = t.size
13920 let state t = t.state
13921 let tag_ids t = t.tag_ids
13922 let taken_after t = t.taken_after
13923 let taken_before t = t.taken_before
13924 let thumbnail_path t = t.thumbnail_path
13925 let trashed_after t = t.trashed_after
13926 let trashed_before t = t.trashed_before
13927 let type_ t = t.type_
13928 let updated_after t = t.updated_after
13929 let updated_before t = t.updated_before
13930 let visibility t = t.visibility
13931 let with_deleted t = t.with_deleted
13932 let with_exif t = t.with_exif
13933 let with_people t = t.with_people
13934 let with_stacked t = t.with_stacked
13935
13936 let jsont : t Jsont.t =
13937 Jsont.Object.map ~kind:"MetadataSearchDto"
13938 (fun album_ids checksum city country created_after created_before description device_asset_id device_id encoded_video_path id is_encoded is_favorite is_motion is_not_in_album is_offline lens_model library_id make model ocr order original_file_name original_path page person_ids preview_path rating size state tag_ids taken_after taken_before thumbnail_path trashed_after trashed_before type_ updated_after updated_before visibility with_deleted with_exif with_people with_stacked -> { album_ids; checksum; city; country; created_after; created_before; description; device_asset_id; device_id; encoded_video_path; id; is_encoded; is_favorite; is_motion; is_not_in_album; is_offline; lens_model; library_id; make; model; ocr; order; original_file_name; original_path; page; person_ids; preview_path; rating; size; state; tag_ids; taken_after; taken_before; thumbnail_path; trashed_after; trashed_before; type_; updated_after; updated_before; visibility; with_deleted; with_exif; with_people; with_stacked })
13939 |> Jsont.Object.opt_mem "albumIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.album_ids)
13940 |> Jsont.Object.opt_mem "checksum" Jsont.string ~enc:(fun r -> r.checksum)
13941 |> Jsont.Object.mem "city" Openapi.Runtime.nullable_string
13942 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.city)
13943 |> Jsont.Object.mem "country" Openapi.Runtime.nullable_string
13944 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.country)
13945 |> Jsont.Object.opt_mem "createdAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_after)
13946 |> Jsont.Object.opt_mem "createdBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_before)
13947 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
13948 |> Jsont.Object.opt_mem "deviceAssetId" Jsont.string ~enc:(fun r -> r.device_asset_id)
13949 |> Jsont.Object.opt_mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
13950 |> Jsont.Object.opt_mem "encodedVideoPath" Jsont.string ~enc:(fun r -> r.encoded_video_path)
13951 |> Jsont.Object.opt_mem "id" Jsont.string ~enc:(fun r -> r.id)
13952 |> Jsont.Object.opt_mem "isEncoded" Jsont.bool ~enc:(fun r -> r.is_encoded)
13953 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
13954 |> Jsont.Object.opt_mem "isMotion" Jsont.bool ~enc:(fun r -> r.is_motion)
13955 |> Jsont.Object.opt_mem "isNotInAlbum" Jsont.bool ~enc:(fun r -> r.is_not_in_album)
13956 |> Jsont.Object.opt_mem "isOffline" Jsont.bool ~enc:(fun r -> r.is_offline)
13957 |> Jsont.Object.mem "lensModel" Openapi.Runtime.nullable_string
13958 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.lens_model)
13959 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
13960 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
13961 |> Jsont.Object.opt_mem "make" Jsont.string ~enc:(fun r -> r.make)
13962 |> Jsont.Object.mem "model" Openapi.Runtime.nullable_string
13963 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.model)
13964 |> Jsont.Object.opt_mem "ocr" Jsont.string ~enc:(fun r -> r.ocr)
13965 |> Jsont.Object.mem "order" AssetOrder.T.jsont ~dec_absent:`Desc ~enc:(fun r -> r.order)
13966 |> Jsont.Object.opt_mem "originalFileName" Jsont.string ~enc:(fun r -> r.original_file_name)
13967 |> Jsont.Object.opt_mem "originalPath" Jsont.string ~enc:(fun r -> r.original_path)
13968 |> Jsont.Object.opt_mem "page" (Openapi.Runtime.validated_float ~minimum:1. Jsont.number) ~enc:(fun r -> r.page)
13969 |> Jsont.Object.opt_mem "personIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.person_ids)
13970 |> Jsont.Object.opt_mem "previewPath" Jsont.string ~enc:(fun r -> r.preview_path)
13971 |> Jsont.Object.opt_mem "rating" (Openapi.Runtime.validated_float ~minimum:(-1.) ~maximum:5. Jsont.number) ~enc:(fun r -> r.rating)
13972 |> Jsont.Object.opt_mem "size" (Openapi.Runtime.validated_float ~minimum:1. ~maximum:1000. Jsont.number) ~enc:(fun r -> r.size)
13973 |> Jsont.Object.mem "state" Openapi.Runtime.nullable_string
13974 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.state)
13975 |> Jsont.Object.mem "tagIds" (Openapi.Runtime.nullable_any (Jsont.list Jsont.string))
13976 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.tag_ids)
13977 |> Jsont.Object.opt_mem "takenAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_after)
13978 |> Jsont.Object.opt_mem "takenBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.taken_before)
13979 |> Jsont.Object.opt_mem "thumbnailPath" Jsont.string ~enc:(fun r -> r.thumbnail_path)
13980 |> Jsont.Object.opt_mem "trashedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_after)
13981 |> Jsont.Object.opt_mem "trashedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.trashed_before)
13982 |> Jsont.Object.opt_mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
13983 |> Jsont.Object.opt_mem "updatedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_after)
13984 |> Jsont.Object.opt_mem "updatedBefore" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_before)
13985 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
13986 |> Jsont.Object.opt_mem "withDeleted" Jsont.bool ~enc:(fun r -> r.with_deleted)
13987 |> Jsont.Object.opt_mem "withExif" Jsont.bool ~enc:(fun r -> r.with_exif)
13988 |> Jsont.Object.opt_mem "withPeople" Jsont.bool ~enc:(fun r -> r.with_people)
13989 |> Jsont.Object.opt_mem "withStacked" Jsont.bool ~enc:(fun r -> r.with_stacked)
13990 |> Jsont.Object.skip_unknown
13991 |> Jsont.Object.finish
13992 end
13993end
13994
13995module Albums = struct
13996 module Types = struct
13997 module Update = struct
13998 type t = {
13999 default_asset_order : AssetOrder.T.t option;
14000 }
14001 end
14002
14003 module Response = struct
14004 type t = {
14005 default_asset_order : AssetOrder.T.t;
14006 }
14007 end
14008 end
14009
14010 module Update = struct
14011 include Types.Update
14012
14013 let v ?default_asset_order () = { default_asset_order }
14014
14015 let default_asset_order t = t.default_asset_order
14016
14017 let jsont : t Jsont.t =
14018 Jsont.Object.map ~kind:"AlbumsUpdate"
14019 (fun default_asset_order -> { default_asset_order })
14020 |> Jsont.Object.opt_mem "defaultAssetOrder" AssetOrder.T.jsont ~enc:(fun r -> r.default_asset_order)
14021 |> Jsont.Object.skip_unknown
14022 |> Jsont.Object.finish
14023 end
14024
14025 module Response = struct
14026 include Types.Response
14027
14028 let v ?(default_asset_order=`Desc) () = { default_asset_order }
14029
14030 let default_asset_order t = t.default_asset_order
14031
14032 let jsont : t Jsont.t =
14033 Jsont.Object.map ~kind:"AlbumsResponse"
14034 (fun default_asset_order -> { default_asset_order })
14035 |> Jsont.Object.mem "defaultAssetOrder" AssetOrder.T.jsont ~dec_absent:`Desc ~enc:(fun r -> r.default_asset_order)
14036 |> Jsont.Object.skip_unknown
14037 |> Jsont.Object.finish
14038 end
14039end
14040
14041module AssetOcr = struct
14042 module Types = struct
14043 module ResponseDto = struct
14044 type t = {
14045 asset_id : string;
14046 box_score : float; (** Confidence score for text detection box *)
14047 id : string;
14048 text : string; (** Recognized text *)
14049 text_score : float; (** Confidence score for text recognition *)
14050 x1 : float; (** Normalized x coordinate of box corner 1 (0-1) *)
14051 x2 : float; (** Normalized x coordinate of box corner 2 (0-1) *)
14052 x3 : float; (** Normalized x coordinate of box corner 3 (0-1) *)
14053 x4 : float; (** Normalized x coordinate of box corner 4 (0-1) *)
14054 y1 : float; (** Normalized y coordinate of box corner 1 (0-1) *)
14055 y2 : float; (** Normalized y coordinate of box corner 2 (0-1) *)
14056 y3 : float; (** Normalized y coordinate of box corner 3 (0-1) *)
14057 y4 : float; (** Normalized y coordinate of box corner 4 (0-1) *)
14058 }
14059 end
14060 end
14061
14062 module ResponseDto = struct
14063 include Types.ResponseDto
14064
14065 let v ~asset_id ~box_score ~id ~text ~text_score ~x1 ~x2 ~x3 ~x4 ~y1 ~y2 ~y3 ~y4 () = { asset_id; box_score; id; text; text_score; x1; x2; x3; x4; y1; y2; y3; y4 }
14066
14067 let asset_id t = t.asset_id
14068 let box_score t = t.box_score
14069 let id t = t.id
14070 let text t = t.text
14071 let text_score t = t.text_score
14072 let x1 t = t.x1
14073 let x2 t = t.x2
14074 let x3 t = t.x3
14075 let x4 t = t.x4
14076 let y1 t = t.y1
14077 let y2 t = t.y2
14078 let y3 t = t.y3
14079 let y4 t = t.y4
14080
14081 let jsont : t Jsont.t =
14082 Jsont.Object.map ~kind:"AssetOcrResponseDto"
14083 (fun asset_id box_score id text text_score x1 x2 x3 x4 y1 y2 y3 y4 -> { asset_id; box_score; id; text; text_score; x1; x2; x3; x4; y1; y2; y3; y4 })
14084 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
14085 |> Jsont.Object.mem "boxScore" Jsont.number ~enc:(fun r -> r.box_score)
14086 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
14087 |> Jsont.Object.mem "text" Jsont.string ~enc:(fun r -> r.text)
14088 |> Jsont.Object.mem "textScore" Jsont.number ~enc:(fun r -> r.text_score)
14089 |> Jsont.Object.mem "x1" Jsont.number ~enc:(fun r -> r.x1)
14090 |> Jsont.Object.mem "x2" Jsont.number ~enc:(fun r -> r.x2)
14091 |> Jsont.Object.mem "x3" Jsont.number ~enc:(fun r -> r.x3)
14092 |> Jsont.Object.mem "x4" Jsont.number ~enc:(fun r -> r.x4)
14093 |> Jsont.Object.mem "y1" Jsont.number ~enc:(fun r -> r.y1)
14094 |> Jsont.Object.mem "y2" Jsont.number ~enc:(fun r -> r.y2)
14095 |> Jsont.Object.mem "y3" Jsont.number ~enc:(fun r -> r.y3)
14096 |> Jsont.Object.mem "y4" Jsont.number ~enc:(fun r -> r.y4)
14097 |> Jsont.Object.skip_unknown
14098 |> Jsont.Object.finish
14099 end
14100
14101 (** Retrieve asset OCR data
14102
14103 Retrieve all OCR (Optical Character Recognition) data associated with the specified asset. *)
14104 let get_asset_ocr ~id client () =
14105 let op_name = "get_asset_ocr" in
14106 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/ocr" in
14107 let query = "" in
14108 let url = client.base_url ^ url_path ^ query in
14109 let response =
14110 try Requests.get client.session url
14111 with Eio.Io _ as ex ->
14112 let bt = Printexc.get_raw_backtrace () in
14113 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
14114 in
14115 if Requests.Response.ok response then
14116 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14117 else
14118 let body = Requests.Response.text response in
14119 let parsed_body =
14120 match Jsont_bytesrw.decode_string Jsont.json body with
14121 | Ok json -> Some (Openapi.Runtime.Json json)
14122 | Error _ -> Some (Openapi.Runtime.Raw body)
14123 in
14124 raise (Openapi.Runtime.Api_error {
14125 operation = op_name;
14126 method_ = "GET";
14127 url;
14128 status = Requests.Response.status_code response;
14129 body;
14130 parsed_body;
14131 })
14132end
14133
14134module AssetMetadataUpsertItem = struct
14135 module Types = struct
14136 module Dto = struct
14137 type t = {
14138 key : string;
14139 value : Jsont.json;
14140 }
14141 end
14142 end
14143
14144 module Dto = struct
14145 include Types.Dto
14146
14147 let v ~key ~value () = { key; value }
14148
14149 let key t = t.key
14150 let value t = t.value
14151
14152 let jsont : t Jsont.t =
14153 Jsont.Object.map ~kind:"AssetMetadataUpsertItemDto"
14154 (fun key value -> { key; value })
14155 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
14156 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
14157 |> Jsont.Object.skip_unknown
14158 |> Jsont.Object.finish
14159 end
14160end
14161
14162module AssetMetadataUpsert = struct
14163 module Types = struct
14164 module Dto = struct
14165 type t = {
14166 items : AssetMetadataUpsertItem.Dto.t list;
14167 }
14168 end
14169 end
14170
14171 module Dto = struct
14172 include Types.Dto
14173
14174 let v ~items () = { items }
14175
14176 let items t = t.items
14177
14178 let jsont : t Jsont.t =
14179 Jsont.Object.map ~kind:"AssetMetadataUpsertDto"
14180 (fun items -> { items })
14181 |> Jsont.Object.mem "items" (Jsont.list AssetMetadataUpsertItem.Dto.jsont) ~enc:(fun r -> r.items)
14182 |> Jsont.Object.skip_unknown
14183 |> Jsont.Object.finish
14184 end
14185end
14186
14187module AssetMetadata = struct
14188 module Types = struct
14189 module ResponseDto = struct
14190 type t = {
14191 key : string;
14192 updated_at : Ptime.t;
14193 value : Jsont.json;
14194 }
14195 end
14196 end
14197
14198 module ResponseDto = struct
14199 include Types.ResponseDto
14200
14201 let v ~key ~updated_at ~value () = { key; updated_at; value }
14202
14203 let key t = t.key
14204 let updated_at t = t.updated_at
14205 let value t = t.value
14206
14207 let jsont : t Jsont.t =
14208 Jsont.Object.map ~kind:"AssetMetadataResponseDto"
14209 (fun key updated_at value -> { key; updated_at; value })
14210 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
14211 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
14212 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
14213 |> Jsont.Object.skip_unknown
14214 |> Jsont.Object.finish
14215 end
14216
14217 (** Get asset metadata
14218
14219 Retrieve all metadata key-value pairs associated with the specified asset. *)
14220 let get_asset_metadata ~id client () =
14221 let op_name = "get_asset_metadata" in
14222 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/metadata" in
14223 let query = "" in
14224 let url = client.base_url ^ url_path ^ query in
14225 let response =
14226 try Requests.get client.session url
14227 with Eio.Io _ as ex ->
14228 let bt = Printexc.get_raw_backtrace () in
14229 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
14230 in
14231 if Requests.Response.ok response then
14232 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14233 else
14234 let body = Requests.Response.text response in
14235 let parsed_body =
14236 match Jsont_bytesrw.decode_string Jsont.json body with
14237 | Ok json -> Some (Openapi.Runtime.Json json)
14238 | Error _ -> Some (Openapi.Runtime.Raw body)
14239 in
14240 raise (Openapi.Runtime.Api_error {
14241 operation = op_name;
14242 method_ = "GET";
14243 url;
14244 status = Requests.Response.status_code response;
14245 body;
14246 parsed_body;
14247 })
14248
14249 (** Update asset metadata
14250
14251 Update or add metadata key-value pairs for the specified asset. *)
14252 let update_asset_metadata ~id ~body client () =
14253 let op_name = "update_asset_metadata" in
14254 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/metadata" in
14255 let query = "" in
14256 let url = client.base_url ^ url_path ^ query in
14257 let response =
14258 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetMetadataUpsert.Dto.jsont body)) url
14259 with Eio.Io _ as ex ->
14260 let bt = Printexc.get_raw_backtrace () in
14261 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
14262 in
14263 if Requests.Response.ok response then
14264 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14265 else
14266 let body = Requests.Response.text response in
14267 let parsed_body =
14268 match Jsont_bytesrw.decode_string Jsont.json body with
14269 | Ok json -> Some (Openapi.Runtime.Json json)
14270 | Error _ -> Some (Openapi.Runtime.Raw body)
14271 in
14272 raise (Openapi.Runtime.Api_error {
14273 operation = op_name;
14274 method_ = "PUT";
14275 url;
14276 status = Requests.Response.status_code response;
14277 body;
14278 parsed_body;
14279 })
14280
14281 (** Retrieve asset metadata by key
14282
14283 Retrieve the value of a specific metadata key associated with the specified asset. *)
14284 let get_asset_metadata_by_key ~id ~key client () =
14285 let op_name = "get_asset_metadata_by_key" in
14286 let url_path = Openapi.Runtime.Path.render ~params:[("id", id); ("key", key)] "/assets/{id}/metadata/{key}" in
14287 let query = "" in
14288 let url = client.base_url ^ url_path ^ query in
14289 let response =
14290 try Requests.get client.session url
14291 with Eio.Io _ as ex ->
14292 let bt = Printexc.get_raw_backtrace () in
14293 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
14294 in
14295 if Requests.Response.ok response then
14296 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14297 else
14298 let body = Requests.Response.text response in
14299 let parsed_body =
14300 match Jsont_bytesrw.decode_string Jsont.json body with
14301 | Ok json -> Some (Openapi.Runtime.Json json)
14302 | Error _ -> Some (Openapi.Runtime.Raw body)
14303 in
14304 raise (Openapi.Runtime.Api_error {
14305 operation = op_name;
14306 method_ = "GET";
14307 url;
14308 status = Requests.Response.status_code response;
14309 body;
14310 parsed_body;
14311 })
14312end
14313
14314module AssetMedia = struct
14315 module Types = struct
14316 module Status = struct
14317 type t = [
14318 | `Created
14319 | `Replaced
14320 | `Duplicate
14321 ]
14322 end
14323
14324 module ResponseDto = struct
14325 type t = {
14326 id : string;
14327 status : Status.t;
14328 }
14329 end
14330
14331 module CreateDto = struct
14332 type t = {
14333 asset_data : string;
14334 device_asset_id : string;
14335 device_id : string;
14336 duration : string option;
14337 file_created_at : Ptime.t;
14338 file_modified_at : Ptime.t;
14339 filename : string option;
14340 is_favorite : bool option;
14341 live_photo_video_id : string option;
14342 metadata : AssetMetadataUpsertItem.Dto.t list option;
14343 sidecar_data : string option;
14344 visibility : AssetVisibility.T.t option;
14345 }
14346 end
14347 end
14348
14349 module Status = struct
14350 include Types.Status
14351
14352 let jsont : t Jsont.t =
14353 Jsont.map Jsont.string ~kind:"AssetMediaStatus"
14354 ~dec:(function
14355 | "created" -> `Created
14356 | "replaced" -> `Replaced
14357 | "duplicate" -> `Duplicate
14358 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
14359 ~enc:(function
14360 | `Created -> "created"
14361 | `Replaced -> "replaced"
14362 | `Duplicate -> "duplicate")
14363 end
14364
14365 module ResponseDto = struct
14366 include Types.ResponseDto
14367
14368 let v ~id ~status () = { id; status }
14369
14370 let id t = t.id
14371 let status t = t.status
14372
14373 let jsont : t Jsont.t =
14374 Jsont.Object.map ~kind:"AssetMediaResponseDto"
14375 (fun id status -> { id; status })
14376 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
14377 |> Jsont.Object.mem "status" Status.jsont ~enc:(fun r -> r.status)
14378 |> Jsont.Object.skip_unknown
14379 |> Jsont.Object.finish
14380 end
14381
14382 module CreateDto = struct
14383 include Types.CreateDto
14384
14385 let v ~asset_data ~device_asset_id ~device_id ~file_created_at ~file_modified_at ?duration ?filename ?is_favorite ?live_photo_video_id ?metadata ?sidecar_data ?visibility () = { asset_data; device_asset_id; device_id; duration; file_created_at; file_modified_at; filename; is_favorite; live_photo_video_id; metadata; sidecar_data; visibility }
14386
14387 let asset_data t = t.asset_data
14388 let device_asset_id t = t.device_asset_id
14389 let device_id t = t.device_id
14390 let duration t = t.duration
14391 let file_created_at t = t.file_created_at
14392 let file_modified_at t = t.file_modified_at
14393 let filename t = t.filename
14394 let is_favorite t = t.is_favorite
14395 let live_photo_video_id t = t.live_photo_video_id
14396 let metadata t = t.metadata
14397 let sidecar_data t = t.sidecar_data
14398 let visibility t = t.visibility
14399
14400 let jsont : t Jsont.t =
14401 Jsont.Object.map ~kind:"AssetMediaCreateDto"
14402 (fun asset_data device_asset_id device_id duration file_created_at file_modified_at filename is_favorite live_photo_video_id metadata sidecar_data visibility -> { asset_data; device_asset_id; device_id; duration; file_created_at; file_modified_at; filename; is_favorite; live_photo_video_id; metadata; sidecar_data; visibility })
14403 |> Jsont.Object.mem "assetData" Jsont.string ~enc:(fun r -> r.asset_data)
14404 |> Jsont.Object.mem "deviceAssetId" Jsont.string ~enc:(fun r -> r.device_asset_id)
14405 |> Jsont.Object.mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
14406 |> Jsont.Object.opt_mem "duration" Jsont.string ~enc:(fun r -> r.duration)
14407 |> Jsont.Object.mem "fileCreatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_created_at)
14408 |> Jsont.Object.mem "fileModifiedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_modified_at)
14409 |> Jsont.Object.opt_mem "filename" Jsont.string ~enc:(fun r -> r.filename)
14410 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
14411 |> Jsont.Object.opt_mem "livePhotoVideoId" Jsont.string ~enc:(fun r -> r.live_photo_video_id)
14412 |> Jsont.Object.opt_mem "metadata" (Jsont.list AssetMetadataUpsertItem.Dto.jsont) ~enc:(fun r -> r.metadata)
14413 |> Jsont.Object.opt_mem "sidecarData" Jsont.string ~enc:(fun r -> r.sidecar_data)
14414 |> Jsont.Object.opt_mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
14415 |> Jsont.Object.skip_unknown
14416 |> Jsont.Object.finish
14417 end
14418
14419 (** Upload asset
14420
14421 Uploads a new asset to the server. *)
14422 let upload_asset ?key ?slug client () =
14423 let op_name = "upload_asset" in
14424 let url_path = "/assets" in
14425 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
14426 let url = client.base_url ^ url_path ^ query in
14427 let response =
14428 try Requests.post client.session url
14429 with Eio.Io _ as ex ->
14430 let bt = Printexc.get_raw_backtrace () in
14431 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
14432 in
14433 if Requests.Response.ok response then
14434 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14435 else
14436 let body = Requests.Response.text response in
14437 let parsed_body =
14438 match Jsont_bytesrw.decode_string Jsont.json body with
14439 | Ok json -> Some (Openapi.Runtime.Json json)
14440 | Error _ -> Some (Openapi.Runtime.Raw body)
14441 in
14442 raise (Openapi.Runtime.Api_error {
14443 operation = op_name;
14444 method_ = "POST";
14445 url;
14446 status = Requests.Response.status_code response;
14447 body;
14448 parsed_body;
14449 })
14450
14451 (** Replace asset
14452
14453 Replace the asset with new file, without changing its id. *)
14454 let replace_asset ~id ?key ?slug client () =
14455 let op_name = "replace_asset" in
14456 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/original" in
14457 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
14458 let url = client.base_url ^ url_path ^ query in
14459 let response =
14460 try Requests.put client.session url
14461 with Eio.Io _ as ex ->
14462 let bt = Printexc.get_raw_backtrace () in
14463 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
14464 in
14465 if Requests.Response.ok response then
14466 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14467 else
14468 let body = Requests.Response.text response in
14469 let parsed_body =
14470 match Jsont_bytesrw.decode_string Jsont.json body with
14471 | Ok json -> Some (Openapi.Runtime.Json json)
14472 | Error _ -> Some (Openapi.Runtime.Raw body)
14473 in
14474 raise (Openapi.Runtime.Api_error {
14475 operation = op_name;
14476 method_ = "PUT";
14477 url;
14478 status = Requests.Response.status_code response;
14479 body;
14480 parsed_body;
14481 })
14482end
14483
14484module AssetMetadataBulkUpsertItem = struct
14485 module Types = struct
14486 module Dto = struct
14487 type t = {
14488 asset_id : string;
14489 key : string;
14490 value : Jsont.json;
14491 }
14492 end
14493 end
14494
14495 module Dto = struct
14496 include Types.Dto
14497
14498 let v ~asset_id ~key ~value () = { asset_id; key; value }
14499
14500 let asset_id t = t.asset_id
14501 let key t = t.key
14502 let value t = t.value
14503
14504 let jsont : t Jsont.t =
14505 Jsont.Object.map ~kind:"AssetMetadataBulkUpsertItemDto"
14506 (fun asset_id key value -> { asset_id; key; value })
14507 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
14508 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
14509 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
14510 |> Jsont.Object.skip_unknown
14511 |> Jsont.Object.finish
14512 end
14513end
14514
14515module AssetMetadataBulkUpsert = struct
14516 module Types = struct
14517 module Dto = struct
14518 type t = {
14519 items : AssetMetadataBulkUpsertItem.Dto.t list;
14520 }
14521 end
14522 end
14523
14524 module Dto = struct
14525 include Types.Dto
14526
14527 let v ~items () = { items }
14528
14529 let items t = t.items
14530
14531 let jsont : t Jsont.t =
14532 Jsont.Object.map ~kind:"AssetMetadataBulkUpsertDto"
14533 (fun items -> { items })
14534 |> Jsont.Object.mem "items" (Jsont.list AssetMetadataBulkUpsertItem.Dto.jsont) ~enc:(fun r -> r.items)
14535 |> Jsont.Object.skip_unknown
14536 |> Jsont.Object.finish
14537 end
14538end
14539
14540module AssetMetadataBulk = struct
14541 module Types = struct
14542 module ResponseDto = struct
14543 type t = {
14544 asset_id : string;
14545 key : string;
14546 updated_at : Ptime.t;
14547 value : Jsont.json;
14548 }
14549 end
14550 end
14551
14552 module ResponseDto = struct
14553 include Types.ResponseDto
14554
14555 let v ~asset_id ~key ~updated_at ~value () = { asset_id; key; updated_at; value }
14556
14557 let asset_id t = t.asset_id
14558 let key t = t.key
14559 let updated_at t = t.updated_at
14560 let value t = t.value
14561
14562 let jsont : t Jsont.t =
14563 Jsont.Object.map ~kind:"AssetMetadataBulkResponseDto"
14564 (fun asset_id key updated_at value -> { asset_id; key; updated_at; value })
14565 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
14566 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
14567 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
14568 |> Jsont.Object.mem "value" Jsont.json ~enc:(fun r -> r.value)
14569 |> Jsont.Object.skip_unknown
14570 |> Jsont.Object.finish
14571 end
14572
14573 (** Upsert asset metadata
14574
14575 Upsert metadata key-value pairs for multiple assets. *)
14576 let update_bulk_asset_metadata ~body client () =
14577 let op_name = "update_bulk_asset_metadata" in
14578 let url_path = "/assets/metadata" in
14579 let query = "" in
14580 let url = client.base_url ^ url_path ^ query in
14581 let response =
14582 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetMetadataBulkUpsert.Dto.jsont body)) url
14583 with Eio.Io _ as ex ->
14584 let bt = Printexc.get_raw_backtrace () in
14585 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
14586 in
14587 if Requests.Response.ok response then
14588 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14589 else
14590 let body = Requests.Response.text response in
14591 let parsed_body =
14592 match Jsont_bytesrw.decode_string Jsont.json body with
14593 | Ok json -> Some (Openapi.Runtime.Json json)
14594 | Error _ -> Some (Openapi.Runtime.Raw body)
14595 in
14596 raise (Openapi.Runtime.Api_error {
14597 operation = op_name;
14598 method_ = "PUT";
14599 url;
14600 status = Requests.Response.status_code response;
14601 body;
14602 parsed_body;
14603 })
14604end
14605
14606module AssetMetadataBulkDeleteItem = struct
14607 module Types = struct
14608 module Dto = struct
14609 type t = {
14610 asset_id : string;
14611 key : string;
14612 }
14613 end
14614 end
14615
14616 module Dto = struct
14617 include Types.Dto
14618
14619 let v ~asset_id ~key () = { asset_id; key }
14620
14621 let asset_id t = t.asset_id
14622 let key t = t.key
14623
14624 let jsont : t Jsont.t =
14625 Jsont.Object.map ~kind:"AssetMetadataBulkDeleteItemDto"
14626 (fun asset_id key -> { asset_id; key })
14627 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
14628 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
14629 |> Jsont.Object.skip_unknown
14630 |> Jsont.Object.finish
14631 end
14632end
14633
14634module AssetMetadataBulkDelete = struct
14635 module Types = struct
14636 module Dto = struct
14637 type t = {
14638 items : AssetMetadataBulkDeleteItem.Dto.t list;
14639 }
14640 end
14641 end
14642
14643 module Dto = struct
14644 include Types.Dto
14645
14646 let v ~items () = { items }
14647
14648 let items t = t.items
14649
14650 let jsont : t Jsont.t =
14651 Jsont.Object.map ~kind:"AssetMetadataBulkDeleteDto"
14652 (fun items -> { items })
14653 |> Jsont.Object.mem "items" (Jsont.list AssetMetadataBulkDeleteItem.Dto.jsont) ~enc:(fun r -> r.items)
14654 |> Jsont.Object.skip_unknown
14655 |> Jsont.Object.finish
14656 end
14657end
14658
14659module AssetMediaSize = struct
14660 module Types = struct
14661 module T = struct
14662 type t = [
14663 | `Original
14664 | `Fullsize
14665 | `Preview
14666 | `Thumbnail
14667 ]
14668 end
14669 end
14670
14671 module T = struct
14672 include Types.T
14673
14674 let jsont : t Jsont.t =
14675 Jsont.map Jsont.string ~kind:"AssetMediaSize"
14676 ~dec:(function
14677 | "original" -> `Original
14678 | "fullsize" -> `Fullsize
14679 | "preview" -> `Preview
14680 | "thumbnail" -> `Thumbnail
14681 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
14682 ~enc:(function
14683 | `Original -> "original"
14684 | `Fullsize -> "fullsize"
14685 | `Preview -> "preview"
14686 | `Thumbnail -> "thumbnail")
14687 end
14688end
14689
14690module AssetMediaReplace = struct
14691 module Types = struct
14692 module Dto = struct
14693 type t = {
14694 asset_data : string;
14695 device_asset_id : string;
14696 device_id : string;
14697 duration : string option;
14698 file_created_at : Ptime.t;
14699 file_modified_at : Ptime.t;
14700 filename : string option;
14701 }
14702 end
14703 end
14704
14705 module Dto = struct
14706 include Types.Dto
14707
14708 let v ~asset_data ~device_asset_id ~device_id ~file_created_at ~file_modified_at ?duration ?filename () = { asset_data; device_asset_id; device_id; duration; file_created_at; file_modified_at; filename }
14709
14710 let asset_data t = t.asset_data
14711 let device_asset_id t = t.device_asset_id
14712 let device_id t = t.device_id
14713 let duration t = t.duration
14714 let file_created_at t = t.file_created_at
14715 let file_modified_at t = t.file_modified_at
14716 let filename t = t.filename
14717
14718 let jsont : t Jsont.t =
14719 Jsont.Object.map ~kind:"AssetMediaReplaceDto"
14720 (fun asset_data device_asset_id device_id duration file_created_at file_modified_at filename -> { asset_data; device_asset_id; device_id; duration; file_created_at; file_modified_at; filename })
14721 |> Jsont.Object.mem "assetData" Jsont.string ~enc:(fun r -> r.asset_data)
14722 |> Jsont.Object.mem "deviceAssetId" Jsont.string ~enc:(fun r -> r.device_asset_id)
14723 |> Jsont.Object.mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
14724 |> Jsont.Object.opt_mem "duration" Jsont.string ~enc:(fun r -> r.duration)
14725 |> Jsont.Object.mem "fileCreatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_created_at)
14726 |> Jsont.Object.mem "fileModifiedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_modified_at)
14727 |> Jsont.Object.opt_mem "filename" Jsont.string ~enc:(fun r -> r.filename)
14728 |> Jsont.Object.skip_unknown
14729 |> Jsont.Object.finish
14730 end
14731end
14732
14733module AssetJobName = struct
14734 module Types = struct
14735 module T = struct
14736 type t = [
14737 | `Refresh_faces
14738 | `Refresh_metadata
14739 | `Regenerate_thumbnail
14740 | `Transcode_video
14741 ]
14742 end
14743 end
14744
14745 module T = struct
14746 include Types.T
14747
14748 let jsont : t Jsont.t =
14749 Jsont.map Jsont.string ~kind:"AssetJobName"
14750 ~dec:(function
14751 | "refresh-faces" -> `Refresh_faces
14752 | "refresh-metadata" -> `Refresh_metadata
14753 | "regenerate-thumbnail" -> `Regenerate_thumbnail
14754 | "transcode-video" -> `Transcode_video
14755 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
14756 ~enc:(function
14757 | `Refresh_faces -> "refresh-faces"
14758 | `Refresh_metadata -> "refresh-metadata"
14759 | `Regenerate_thumbnail -> "regenerate-thumbnail"
14760 | `Transcode_video -> "transcode-video")
14761 end
14762end
14763
14764module AssetJobs = struct
14765 module Types = struct
14766 module Dto = struct
14767 type t = {
14768 asset_ids : string list;
14769 name : AssetJobName.T.t;
14770 }
14771 end
14772 end
14773
14774 module Dto = struct
14775 include Types.Dto
14776
14777 let v ~asset_ids ~name () = { asset_ids; name }
14778
14779 let asset_ids t = t.asset_ids
14780 let name t = t.name
14781
14782 let jsont : t Jsont.t =
14783 Jsont.Object.map ~kind:"AssetJobsDto"
14784 (fun asset_ids name -> { asset_ids; name })
14785 |> Jsont.Object.mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
14786 |> Jsont.Object.mem "name" AssetJobName.T.jsont ~enc:(fun r -> r.name)
14787 |> Jsont.Object.skip_unknown
14788 |> Jsont.Object.finish
14789 end
14790end
14791
14792module AssetIds = struct
14793 module Types = struct
14794 module ResponseDto = struct
14795 type t = {
14796 asset_id : string;
14797 error : string option;
14798 success : bool;
14799 }
14800 end
14801
14802 module Dto = struct
14803 type t = {
14804 asset_ids : string list;
14805 }
14806 end
14807 end
14808
14809 module ResponseDto = struct
14810 include Types.ResponseDto
14811
14812 let v ~asset_id ~success ?error () = { asset_id; error; success }
14813
14814 let asset_id t = t.asset_id
14815 let error t = t.error
14816 let success t = t.success
14817
14818 let jsont : t Jsont.t =
14819 Jsont.Object.map ~kind:"AssetIdsResponseDto"
14820 (fun asset_id error success -> { asset_id; error; success })
14821 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
14822 |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
14823 |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
14824 |> Jsont.Object.skip_unknown
14825 |> Jsont.Object.finish
14826 end
14827
14828 module Dto = struct
14829 include Types.Dto
14830
14831 let v ~asset_ids () = { asset_ids }
14832
14833 let asset_ids t = t.asset_ids
14834
14835 let jsont : t Jsont.t =
14836 Jsont.Object.map ~kind:"AssetIdsDto"
14837 (fun asset_ids -> { asset_ids })
14838 |> Jsont.Object.mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
14839 |> Jsont.Object.skip_unknown
14840 |> Jsont.Object.finish
14841 end
14842
14843 (** Add assets to a shared link
14844
14845 Add assets to a specific shared link by its ID. This endpoint is only relevant for shared link of type individual. *)
14846 let add_shared_link_assets ~id ?key ?slug ~body client () =
14847 let op_name = "add_shared_link_assets" in
14848 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/shared-links/{id}/assets" in
14849 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
14850 let url = client.base_url ^ url_path ^ query in
14851 let response =
14852 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
14853 with Eio.Io _ as ex ->
14854 let bt = Printexc.get_raw_backtrace () in
14855 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
14856 in
14857 if Requests.Response.ok response then
14858 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14859 else
14860 let body = Requests.Response.text response in
14861 let parsed_body =
14862 match Jsont_bytesrw.decode_string Jsont.json body with
14863 | Ok json -> Some (Openapi.Runtime.Json json)
14864 | Error _ -> Some (Openapi.Runtime.Raw body)
14865 in
14866 raise (Openapi.Runtime.Api_error {
14867 operation = op_name;
14868 method_ = "PUT";
14869 url;
14870 status = Requests.Response.status_code response;
14871 body;
14872 parsed_body;
14873 })
14874
14875 (** Remove assets from a shared link
14876
14877 Remove assets from a specific shared link by its ID. This endpoint is only relevant for shared link of type individual. *)
14878 let remove_shared_link_assets ~id ?key ?slug client () =
14879 let op_name = "remove_shared_link_assets" in
14880 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/shared-links/{id}/assets" in
14881 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
14882 let url = client.base_url ^ url_path ^ query in
14883 let response =
14884 try Requests.delete client.session url
14885 with Eio.Io _ as ex ->
14886 let bt = Printexc.get_raw_backtrace () in
14887 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
14888 in
14889 if Requests.Response.ok response then
14890 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
14891 else
14892 let body = Requests.Response.text response in
14893 let parsed_body =
14894 match Jsont_bytesrw.decode_string Jsont.json body with
14895 | Ok json -> Some (Openapi.Runtime.Json json)
14896 | Error _ -> Some (Openapi.Runtime.Raw body)
14897 in
14898 raise (Openapi.Runtime.Api_error {
14899 operation = op_name;
14900 method_ = "DELETE";
14901 url;
14902 status = Requests.Response.status_code response;
14903 body;
14904 parsed_body;
14905 })
14906end
14907
14908module AssetFullSync = struct
14909 module Types = struct
14910 module Dto = struct
14911 type t = {
14912 last_id : string option;
14913 limit : int;
14914 updated_until : Ptime.t;
14915 user_id : string option;
14916 }
14917 end
14918 end
14919
14920 module Dto = struct
14921 include Types.Dto
14922
14923 let v ~limit ~updated_until ?last_id ?user_id () = { last_id; limit; updated_until; user_id }
14924
14925 let last_id t = t.last_id
14926 let limit t = t.limit
14927 let updated_until t = t.updated_until
14928 let user_id t = t.user_id
14929
14930 let jsont : t Jsont.t =
14931 Jsont.Object.map ~kind:"AssetFullSyncDto"
14932 (fun last_id limit updated_until user_id -> { last_id; limit; updated_until; user_id })
14933 |> Jsont.Object.opt_mem "lastId" Jsont.string ~enc:(fun r -> r.last_id)
14934 |> Jsont.Object.mem "limit" (Openapi.Runtime.validated_int ~minimum:1. Jsont.int) ~enc:(fun r -> r.limit)
14935 |> Jsont.Object.mem "updatedUntil" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_until)
14936 |> Jsont.Object.opt_mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
14937 |> Jsont.Object.skip_unknown
14938 |> Jsont.Object.finish
14939 end
14940end
14941
14942module Asset = struct
14943 module Types = struct
14944 module ResponseDto = struct
14945 type t = {
14946 checksum : string; (** base64 encoded sha1 hash *)
14947 created_at : Ptime.t; (** The UTC timestamp when the asset was originally uploaded to Immich. *)
14948 device_asset_id : string;
14949 device_id : string;
14950 duplicate_id : string option;
14951 duration : string;
14952 exif_info : Exif.ResponseDto.t option;
14953 file_created_at : Ptime.t; (** The actual UTC timestamp when the file was created/captured, preserving timezone information. This is the authoritative timestamp for chronological sorting within timeline groups. Combined with timezone data, this can be used to determine the exact moment the photo was taken. *)
14954 file_modified_at : Ptime.t; (** The UTC timestamp when the file was last modified on the filesystem. This reflects the last time the physical file was changed, which may be different from when the photo was originally taken. *)
14955 has_metadata : bool;
14956 height : float option;
14957 id : string;
14958 is_archived : bool;
14959 is_edited : bool;
14960 is_favorite : bool;
14961 is_offline : bool;
14962 is_trashed : bool;
14963 library_id : string option;
14964 live_photo_video_id : string option;
14965 local_date_time : Ptime.t; (** The local date and time when the photo/video was taken, derived from EXIF metadata. This represents the photographer's local time regardless of timezone, stored as a timezone-agnostic timestamp. Used for timeline grouping by "local" days and months. *)
14966 original_file_name : string;
14967 original_mime_type : string option;
14968 original_path : string;
14969 owner : User.ResponseDto.t option;
14970 owner_id : string;
14971 people : PersonWithFaces.ResponseDto.t list option;
14972 resized : bool option;
14973 stack : AssetStack.ResponseDto.t option;
14974 tags : Tag.ResponseDto.t list option;
14975 thumbhash : string option;
14976 type_ : AssetTypeEnum.T.t;
14977 unassigned_faces : AssetFaceWithoutPerson.ResponseDto.t list option;
14978 updated_at : Ptime.t; (** The UTC timestamp when the asset record was last updated in the database. This is automatically maintained by the database and reflects when any field in the asset was last modified. *)
14979 visibility : AssetVisibility.T.t;
14980 width : float option;
14981 }
14982 end
14983 end
14984
14985 module ResponseDto = struct
14986 include Types.ResponseDto
14987
14988 let v ~checksum ~created_at ~device_asset_id ~device_id ~duration ~file_created_at ~file_modified_at ~has_metadata ~id ~is_archived ~is_edited ~is_favorite ~is_offline ~is_trashed ~local_date_time ~original_file_name ~original_path ~owner_id ~type_ ~updated_at ~visibility ?duplicate_id ?exif_info ?height ?library_id ?live_photo_video_id ?original_mime_type ?owner ?people ?resized ?stack ?tags ?thumbhash ?unassigned_faces ?width () = { checksum; created_at; device_asset_id; device_id; duplicate_id; duration; exif_info; file_created_at; file_modified_at; has_metadata; height; id; is_archived; is_edited; is_favorite; is_offline; is_trashed; library_id; live_photo_video_id; local_date_time; original_file_name; original_mime_type; original_path; owner; owner_id; people; resized; stack; tags; thumbhash; type_; unassigned_faces; updated_at; visibility; width }
14989
14990 let checksum t = t.checksum
14991 let created_at t = t.created_at
14992 let device_asset_id t = t.device_asset_id
14993 let device_id t = t.device_id
14994 let duplicate_id t = t.duplicate_id
14995 let duration t = t.duration
14996 let exif_info t = t.exif_info
14997 let file_created_at t = t.file_created_at
14998 let file_modified_at t = t.file_modified_at
14999 let has_metadata t = t.has_metadata
15000 let height t = t.height
15001 let id t = t.id
15002 let is_archived t = t.is_archived
15003 let is_edited t = t.is_edited
15004 let is_favorite t = t.is_favorite
15005 let is_offline t = t.is_offline
15006 let is_trashed t = t.is_trashed
15007 let library_id t = t.library_id
15008 let live_photo_video_id t = t.live_photo_video_id
15009 let local_date_time t = t.local_date_time
15010 let original_file_name t = t.original_file_name
15011 let original_mime_type t = t.original_mime_type
15012 let original_path t = t.original_path
15013 let owner t = t.owner
15014 let owner_id t = t.owner_id
15015 let people t = t.people
15016 let resized t = t.resized
15017 let stack t = t.stack
15018 let tags t = t.tags
15019 let thumbhash t = t.thumbhash
15020 let type_ t = t.type_
15021 let unassigned_faces t = t.unassigned_faces
15022 let updated_at t = t.updated_at
15023 let visibility t = t.visibility
15024 let width t = t.width
15025
15026 let jsont : t Jsont.t =
15027 Jsont.Object.map ~kind:"AssetResponseDto"
15028 (fun checksum created_at device_asset_id device_id duplicate_id duration exif_info file_created_at file_modified_at has_metadata height id is_archived is_edited is_favorite is_offline is_trashed library_id live_photo_video_id local_date_time original_file_name original_mime_type original_path owner owner_id people resized stack tags thumbhash type_ unassigned_faces updated_at visibility width -> { checksum; created_at; device_asset_id; device_id; duplicate_id; duration; exif_info; file_created_at; file_modified_at; has_metadata; height; id; is_archived; is_edited; is_favorite; is_offline; is_trashed; library_id; live_photo_video_id; local_date_time; original_file_name; original_mime_type; original_path; owner; owner_id; people; resized; stack; tags; thumbhash; type_; unassigned_faces; updated_at; visibility; width })
15029 |> Jsont.Object.mem "checksum" Jsont.string ~enc:(fun r -> r.checksum)
15030 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
15031 |> Jsont.Object.mem "deviceAssetId" Jsont.string ~enc:(fun r -> r.device_asset_id)
15032 |> Jsont.Object.mem "deviceId" Jsont.string ~enc:(fun r -> r.device_id)
15033 |> Jsont.Object.mem "duplicateId" Openapi.Runtime.nullable_string
15034 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.duplicate_id)
15035 |> Jsont.Object.mem "duration" Jsont.string ~enc:(fun r -> r.duration)
15036 |> Jsont.Object.opt_mem "exifInfo" Exif.ResponseDto.jsont ~enc:(fun r -> r.exif_info)
15037 |> Jsont.Object.mem "fileCreatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_created_at)
15038 |> Jsont.Object.mem "fileModifiedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.file_modified_at)
15039 |> Jsont.Object.mem "hasMetadata" Jsont.bool ~enc:(fun r -> r.has_metadata)
15040 |> Jsont.Object.mem "height" Openapi.Runtime.nullable_float
15041 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.height)
15042 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
15043 |> Jsont.Object.mem "isArchived" Jsont.bool ~enc:(fun r -> r.is_archived)
15044 |> Jsont.Object.mem "isEdited" Jsont.bool ~enc:(fun r -> r.is_edited)
15045 |> Jsont.Object.mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
15046 |> Jsont.Object.mem "isOffline" Jsont.bool ~enc:(fun r -> r.is_offline)
15047 |> Jsont.Object.mem "isTrashed" Jsont.bool ~enc:(fun r -> r.is_trashed)
15048 |> Jsont.Object.mem "libraryId" Openapi.Runtime.nullable_string
15049 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.library_id)
15050 |> Jsont.Object.mem "livePhotoVideoId" Openapi.Runtime.nullable_string
15051 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.live_photo_video_id)
15052 |> Jsont.Object.mem "localDateTime" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.local_date_time)
15053 |> Jsont.Object.mem "originalFileName" Jsont.string ~enc:(fun r -> r.original_file_name)
15054 |> Jsont.Object.opt_mem "originalMimeType" Jsont.string ~enc:(fun r -> r.original_mime_type)
15055 |> Jsont.Object.mem "originalPath" Jsont.string ~enc:(fun r -> r.original_path)
15056 |> Jsont.Object.opt_mem "owner" User.ResponseDto.jsont ~enc:(fun r -> r.owner)
15057 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
15058 |> Jsont.Object.opt_mem "people" (Jsont.list PersonWithFaces.ResponseDto.jsont) ~enc:(fun r -> r.people)
15059 |> Jsont.Object.opt_mem "resized" Jsont.bool ~enc:(fun r -> r.resized)
15060 |> Jsont.Object.opt_mem "stack" AssetStack.ResponseDto.jsont ~enc:(fun r -> r.stack)
15061 |> Jsont.Object.opt_mem "tags" (Jsont.list Tag.ResponseDto.jsont) ~enc:(fun r -> r.tags)
15062 |> Jsont.Object.mem "thumbhash" Openapi.Runtime.nullable_string
15063 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.thumbhash)
15064 |> Jsont.Object.mem "type" AssetTypeEnum.T.jsont ~enc:(fun r -> r.type_)
15065 |> Jsont.Object.opt_mem "unassignedFaces" (Jsont.list AssetFaceWithoutPerson.ResponseDto.jsont) ~enc:(fun r -> r.unassigned_faces)
15066 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
15067 |> Jsont.Object.mem "visibility" AssetVisibility.T.jsont ~enc:(fun r -> r.visibility)
15068 |> Jsont.Object.mem "width" Openapi.Runtime.nullable_float
15069 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.width)
15070 |> Jsont.Object.skip_unknown
15071 |> Jsont.Object.finish
15072 end
15073
15074 (** Get random assets
15075
15076 Retrieve a specified number of random assets for the authenticated user. *)
15077 let get_random ?count client () =
15078 let op_name = "get_random" in
15079 let url_path = "/assets/random" in
15080 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"count" ~value:count]) in
15081 let url = client.base_url ^ url_path ^ query in
15082 let response =
15083 try Requests.get client.session url
15084 with Eio.Io _ as ex ->
15085 let bt = Printexc.get_raw_backtrace () in
15086 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15087 in
15088 if Requests.Response.ok response then
15089 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15090 else
15091 let body = Requests.Response.text response in
15092 let parsed_body =
15093 match Jsont_bytesrw.decode_string Jsont.json body with
15094 | Ok json -> Some (Openapi.Runtime.Json json)
15095 | Error _ -> Some (Openapi.Runtime.Raw body)
15096 in
15097 raise (Openapi.Runtime.Api_error {
15098 operation = op_name;
15099 method_ = "GET";
15100 url;
15101 status = Requests.Response.status_code response;
15102 body;
15103 parsed_body;
15104 })
15105
15106 (** Retrieve an asset
15107
15108 Retrieve detailed information about a specific asset. *)
15109 let get_asset_info ~id ?key ?slug client () =
15110 let op_name = "get_asset_info" in
15111 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}" in
15112 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
15113 let url = client.base_url ^ url_path ^ query in
15114 let response =
15115 try Requests.get client.session url
15116 with Eio.Io _ as ex ->
15117 let bt = Printexc.get_raw_backtrace () in
15118 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15119 in
15120 if Requests.Response.ok response then
15121 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15122 else
15123 let body = Requests.Response.text response in
15124 let parsed_body =
15125 match Jsont_bytesrw.decode_string Jsont.json body with
15126 | Ok json -> Some (Openapi.Runtime.Json json)
15127 | Error _ -> Some (Openapi.Runtime.Raw body)
15128 in
15129 raise (Openapi.Runtime.Api_error {
15130 operation = op_name;
15131 method_ = "GET";
15132 url;
15133 status = Requests.Response.status_code response;
15134 body;
15135 parsed_body;
15136 })
15137
15138 (** Update an asset
15139
15140 Update information of a specific asset. *)
15141 let update_asset ~id ~body client () =
15142 let op_name = "update_asset" in
15143 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}" in
15144 let query = "" in
15145 let url = client.base_url ^ url_path ^ query in
15146 let response =
15147 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateAsset.Dto.jsont body)) url
15148 with Eio.Io _ as ex ->
15149 let bt = Printexc.get_raw_backtrace () in
15150 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
15151 in
15152 if Requests.Response.ok response then
15153 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15154 else
15155 let body = Requests.Response.text response in
15156 let parsed_body =
15157 match Jsont_bytesrw.decode_string Jsont.json body with
15158 | Ok json -> Some (Openapi.Runtime.Json json)
15159 | Error _ -> Some (Openapi.Runtime.Raw body)
15160 in
15161 raise (Openapi.Runtime.Api_error {
15162 operation = op_name;
15163 method_ = "PUT";
15164 url;
15165 status = Requests.Response.status_code response;
15166 body;
15167 parsed_body;
15168 })
15169
15170 (** Retrieve assets by city
15171
15172 Retrieve a list of assets with each asset belonging to a different city. This endpoint is used on the places pages to show a single thumbnail for each city the user has assets in. *)
15173 let get_assets_by_city client () =
15174 let op_name = "get_assets_by_city" in
15175 let url_path = "/search/cities" in
15176 let query = "" in
15177 let url = client.base_url ^ url_path ^ query in
15178 let response =
15179 try Requests.get client.session url
15180 with Eio.Io _ as ex ->
15181 let bt = Printexc.get_raw_backtrace () in
15182 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15183 in
15184 if Requests.Response.ok response then
15185 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15186 else
15187 let body = Requests.Response.text response in
15188 let parsed_body =
15189 match Jsont_bytesrw.decode_string Jsont.json body with
15190 | Ok json -> Some (Openapi.Runtime.Json json)
15191 | Error _ -> Some (Openapi.Runtime.Raw body)
15192 in
15193 raise (Openapi.Runtime.Api_error {
15194 operation = op_name;
15195 method_ = "GET";
15196 url;
15197 status = Requests.Response.status_code response;
15198 body;
15199 parsed_body;
15200 })
15201
15202 (** Search large assets
15203
15204 Search for assets that are considered large based on specified criteria. *)
15205 let search_large_assets ?album_ids ?city ?country ?created_after ?created_before ?device_id ?is_encoded ?is_favorite ?is_motion ?is_not_in_album ?is_offline ?lens_model ?library_id ?make ?min_file_size ?model ?ocr ?person_ids ?rating ?size ?state ?tag_ids ?taken_after ?taken_before ?trashed_after ?trashed_before ?type_ ?updated_after ?updated_before ?visibility ?with_deleted ?with_exif client () =
15206 let op_name = "search_large_assets" in
15207 let url_path = "/search/large-assets" in
15208 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"albumIds" ~value:album_ids; Openapi.Runtime.Query.optional ~key:"city" ~value:city; Openapi.Runtime.Query.optional ~key:"country" ~value:country; Openapi.Runtime.Query.optional ~key:"createdAfter" ~value:created_after; Openapi.Runtime.Query.optional ~key:"createdBefore" ~value:created_before; Openapi.Runtime.Query.optional ~key:"deviceId" ~value:device_id; Openapi.Runtime.Query.optional ~key:"isEncoded" ~value:is_encoded; Openapi.Runtime.Query.optional ~key:"isFavorite" ~value:is_favorite; Openapi.Runtime.Query.optional ~key:"isMotion" ~value:is_motion; Openapi.Runtime.Query.optional ~key:"isNotInAlbum" ~value:is_not_in_album; Openapi.Runtime.Query.optional ~key:"isOffline" ~value:is_offline; Openapi.Runtime.Query.optional ~key:"lensModel" ~value:lens_model; Openapi.Runtime.Query.optional ~key:"libraryId" ~value:library_id; Openapi.Runtime.Query.optional ~key:"make" ~value:make; Openapi.Runtime.Query.optional ~key:"minFileSize" ~value:min_file_size; Openapi.Runtime.Query.optional ~key:"model" ~value:model; Openapi.Runtime.Query.optional ~key:"ocr" ~value:ocr; Openapi.Runtime.Query.optional ~key:"personIds" ~value:person_ids; Openapi.Runtime.Query.optional ~key:"rating" ~value:rating; Openapi.Runtime.Query.optional ~key:"size" ~value:size; Openapi.Runtime.Query.optional ~key:"state" ~value:state; Openapi.Runtime.Query.optional ~key:"tagIds" ~value:tag_ids; Openapi.Runtime.Query.optional ~key:"takenAfter" ~value:taken_after; Openapi.Runtime.Query.optional ~key:"takenBefore" ~value:taken_before; Openapi.Runtime.Query.optional ~key:"trashedAfter" ~value:trashed_after; Openapi.Runtime.Query.optional ~key:"trashedBefore" ~value:trashed_before; Openapi.Runtime.Query.optional ~key:"type" ~value:type_; Openapi.Runtime.Query.optional ~key:"updatedAfter" ~value:updated_after; Openapi.Runtime.Query.optional ~key:"updatedBefore" ~value:updated_before; Openapi.Runtime.Query.optional ~key:"visibility" ~value:visibility; Openapi.Runtime.Query.optional ~key:"withDeleted" ~value:with_deleted; Openapi.Runtime.Query.optional ~key:"withExif" ~value:with_exif]) in
15209 let url = client.base_url ^ url_path ^ query in
15210 let response =
15211 try Requests.post client.session url
15212 with Eio.Io _ as ex ->
15213 let bt = Printexc.get_raw_backtrace () in
15214 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
15215 in
15216 if Requests.Response.ok response then
15217 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15218 else
15219 let body = Requests.Response.text response in
15220 let parsed_body =
15221 match Jsont_bytesrw.decode_string Jsont.json body with
15222 | Ok json -> Some (Openapi.Runtime.Json json)
15223 | Error _ -> Some (Openapi.Runtime.Raw body)
15224 in
15225 raise (Openapi.Runtime.Api_error {
15226 operation = op_name;
15227 method_ = "POST";
15228 url;
15229 status = Requests.Response.status_code response;
15230 body;
15231 parsed_body;
15232 })
15233
15234 (** Search random assets
15235
15236 Retrieve a random selection of assets based on the provided criteria. *)
15237 let search_random ~body client () =
15238 let op_name = "search_random" in
15239 let url_path = "/search/random" in
15240 let query = "" in
15241 let url = client.base_url ^ url_path ^ query in
15242 let response =
15243 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json RandomSearch.Dto.jsont body)) url
15244 with Eio.Io _ as ex ->
15245 let bt = Printexc.get_raw_backtrace () in
15246 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
15247 in
15248 if Requests.Response.ok response then
15249 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15250 else
15251 let body = Requests.Response.text response in
15252 let parsed_body =
15253 match Jsont_bytesrw.decode_string Jsont.json body with
15254 | Ok json -> Some (Openapi.Runtime.Json json)
15255 | Error _ -> Some (Openapi.Runtime.Raw body)
15256 in
15257 raise (Openapi.Runtime.Api_error {
15258 operation = op_name;
15259 method_ = "POST";
15260 url;
15261 status = Requests.Response.status_code response;
15262 body;
15263 parsed_body;
15264 })
15265
15266 (** Get full sync for user
15267
15268 Retrieve all assets for a full synchronization for the authenticated user. *)
15269 let get_full_sync_for_user ~body client () =
15270 let op_name = "get_full_sync_for_user" in
15271 let url_path = "/sync/full-sync" in
15272 let query = "" in
15273 let url = client.base_url ^ url_path ^ query in
15274 let response =
15275 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetFullSync.Dto.jsont body)) url
15276 with Eio.Io _ as ex ->
15277 let bt = Printexc.get_raw_backtrace () in
15278 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
15279 in
15280 if Requests.Response.ok response then
15281 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15282 else
15283 let body = Requests.Response.text response in
15284 let parsed_body =
15285 match Jsont_bytesrw.decode_string Jsont.json body with
15286 | Ok json -> Some (Openapi.Runtime.Json json)
15287 | Error _ -> Some (Openapi.Runtime.Raw body)
15288 in
15289 raise (Openapi.Runtime.Api_error {
15290 operation = op_name;
15291 method_ = "POST";
15292 url;
15293 status = Requests.Response.status_code response;
15294 body;
15295 parsed_body;
15296 })
15297
15298 (** Retrieve assets by original path
15299
15300 Retrieve assets that are children of a specific folder. *)
15301 let get_assets_by_original_path ~path client () =
15302 let op_name = "get_assets_by_original_path" in
15303 let url_path = "/view/folder" in
15304 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"path" ~value:path]) in
15305 let url = client.base_url ^ url_path ^ query in
15306 let response =
15307 try Requests.get client.session url
15308 with Eio.Io _ as ex ->
15309 let bt = Printexc.get_raw_backtrace () in
15310 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15311 in
15312 if Requests.Response.ok response then
15313 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15314 else
15315 let body = Requests.Response.text response in
15316 let parsed_body =
15317 match Jsont_bytesrw.decode_string Jsont.json body with
15318 | Ok json -> Some (Openapi.Runtime.Json json)
15319 | Error _ -> Some (Openapi.Runtime.Raw body)
15320 in
15321 raise (Openapi.Runtime.Api_error {
15322 operation = op_name;
15323 method_ = "GET";
15324 url;
15325 status = Requests.Response.status_code response;
15326 body;
15327 parsed_body;
15328 })
15329end
15330
15331module Stack = struct
15332 module Types = struct
15333 module UpdateDto = struct
15334 type t = {
15335 primary_asset_id : string option;
15336 }
15337 end
15338
15339 module ResponseDto = struct
15340 type t = {
15341 assets : Asset.ResponseDto.t list;
15342 id : string;
15343 primary_asset_id : string;
15344 }
15345 end
15346
15347 module CreateDto = struct
15348 type t = {
15349 asset_ids : string list; (** first asset becomes the primary *)
15350 }
15351 end
15352 end
15353
15354 module UpdateDto = struct
15355 include Types.UpdateDto
15356
15357 let v ?primary_asset_id () = { primary_asset_id }
15358
15359 let primary_asset_id t = t.primary_asset_id
15360
15361 let jsont : t Jsont.t =
15362 Jsont.Object.map ~kind:"StackUpdateDto"
15363 (fun primary_asset_id -> { primary_asset_id })
15364 |> Jsont.Object.opt_mem "primaryAssetId" Jsont.string ~enc:(fun r -> r.primary_asset_id)
15365 |> Jsont.Object.skip_unknown
15366 |> Jsont.Object.finish
15367 end
15368
15369 module ResponseDto = struct
15370 include Types.ResponseDto
15371
15372 let v ~assets ~id ~primary_asset_id () = { assets; id; primary_asset_id }
15373
15374 let assets t = t.assets
15375 let id t = t.id
15376 let primary_asset_id t = t.primary_asset_id
15377
15378 let jsont : t Jsont.t =
15379 Jsont.Object.map ~kind:"StackResponseDto"
15380 (fun assets id primary_asset_id -> { assets; id; primary_asset_id })
15381 |> Jsont.Object.mem "assets" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.assets)
15382 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
15383 |> Jsont.Object.mem "primaryAssetId" Jsont.string ~enc:(fun r -> r.primary_asset_id)
15384 |> Jsont.Object.skip_unknown
15385 |> Jsont.Object.finish
15386 end
15387
15388 module CreateDto = struct
15389 include Types.CreateDto
15390
15391 let v ~asset_ids () = { asset_ids }
15392
15393 let asset_ids t = t.asset_ids
15394
15395 let jsont : t Jsont.t =
15396 Jsont.Object.map ~kind:"StackCreateDto"
15397 (fun asset_ids -> { asset_ids })
15398 |> Jsont.Object.mem "assetIds" (Openapi.Runtime.validated_list ~min_items:2 Jsont.string) ~enc:(fun r -> r.asset_ids)
15399 |> Jsont.Object.skip_unknown
15400 |> Jsont.Object.finish
15401 end
15402
15403 (** Retrieve stacks
15404
15405 Retrieve a list of stacks. *)
15406 let search_stacks ?primary_asset_id client () =
15407 let op_name = "search_stacks" in
15408 let url_path = "/stacks" in
15409 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"primaryAssetId" ~value:primary_asset_id]) in
15410 let url = client.base_url ^ url_path ^ query in
15411 let response =
15412 try Requests.get client.session url
15413 with Eio.Io _ as ex ->
15414 let bt = Printexc.get_raw_backtrace () in
15415 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15416 in
15417 if Requests.Response.ok response then
15418 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15419 else
15420 let body = Requests.Response.text response in
15421 let parsed_body =
15422 match Jsont_bytesrw.decode_string Jsont.json body with
15423 | Ok json -> Some (Openapi.Runtime.Json json)
15424 | Error _ -> Some (Openapi.Runtime.Raw body)
15425 in
15426 raise (Openapi.Runtime.Api_error {
15427 operation = op_name;
15428 method_ = "GET";
15429 url;
15430 status = Requests.Response.status_code response;
15431 body;
15432 parsed_body;
15433 })
15434
15435 (** Create a stack
15436
15437 Create a new stack by providing a name and a list of asset IDs to include in the stack. If any of the provided asset IDs are primary assets of an existing stack, the existing stack will be merged into the newly created stack. *)
15438 let create_stack ~body client () =
15439 let op_name = "create_stack" in
15440 let url_path = "/stacks" in
15441 let query = "" in
15442 let url = client.base_url ^ url_path ^ query in
15443 let response =
15444 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
15445 with Eio.Io _ as ex ->
15446 let bt = Printexc.get_raw_backtrace () in
15447 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
15448 in
15449 if Requests.Response.ok response then
15450 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15451 else
15452 let body = Requests.Response.text response in
15453 let parsed_body =
15454 match Jsont_bytesrw.decode_string Jsont.json body with
15455 | Ok json -> Some (Openapi.Runtime.Json json)
15456 | Error _ -> Some (Openapi.Runtime.Raw body)
15457 in
15458 raise (Openapi.Runtime.Api_error {
15459 operation = op_name;
15460 method_ = "POST";
15461 url;
15462 status = Requests.Response.status_code response;
15463 body;
15464 parsed_body;
15465 })
15466
15467 (** Retrieve a stack
15468
15469 Retrieve a specific stack by its ID. *)
15470 let get_stack ~id client () =
15471 let op_name = "get_stack" in
15472 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/stacks/{id}" in
15473 let query = "" in
15474 let url = client.base_url ^ url_path ^ query in
15475 let response =
15476 try Requests.get client.session url
15477 with Eio.Io _ as ex ->
15478 let bt = Printexc.get_raw_backtrace () in
15479 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15480 in
15481 if Requests.Response.ok response then
15482 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15483 else
15484 let body = Requests.Response.text response in
15485 let parsed_body =
15486 match Jsont_bytesrw.decode_string Jsont.json body with
15487 | Ok json -> Some (Openapi.Runtime.Json json)
15488 | Error _ -> Some (Openapi.Runtime.Raw body)
15489 in
15490 raise (Openapi.Runtime.Api_error {
15491 operation = op_name;
15492 method_ = "GET";
15493 url;
15494 status = Requests.Response.status_code response;
15495 body;
15496 parsed_body;
15497 })
15498
15499 (** Update a stack
15500
15501 Update an existing stack by its ID. *)
15502 let update_stack ~id ~body client () =
15503 let op_name = "update_stack" in
15504 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/stacks/{id}" in
15505 let query = "" in
15506 let url = client.base_url ^ url_path ^ query in
15507 let response =
15508 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
15509 with Eio.Io _ as ex ->
15510 let bt = Printexc.get_raw_backtrace () in
15511 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
15512 in
15513 if Requests.Response.ok response then
15514 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15515 else
15516 let body = Requests.Response.text response in
15517 let parsed_body =
15518 match Jsont_bytesrw.decode_string Jsont.json body with
15519 | Ok json -> Some (Openapi.Runtime.Json json)
15520 | Error _ -> Some (Openapi.Runtime.Raw body)
15521 in
15522 raise (Openapi.Runtime.Api_error {
15523 operation = op_name;
15524 method_ = "PUT";
15525 url;
15526 status = Requests.Response.status_code response;
15527 body;
15528 parsed_body;
15529 })
15530end
15531
15532module SearchExplore = struct
15533 module Types = struct
15534 module Item = struct
15535 type t = {
15536 data : Asset.ResponseDto.t;
15537 value : string;
15538 }
15539 end
15540
15541 module ResponseDto = struct
15542 type t = {
15543 field_name : string;
15544 items : Item.t list;
15545 }
15546 end
15547 end
15548
15549 module Item = struct
15550 include Types.Item
15551
15552 let v ~data ~value () = { data; value }
15553
15554 let data t = t.data
15555 let value t = t.value
15556
15557 let jsont : t Jsont.t =
15558 Jsont.Object.map ~kind:"SearchExploreItem"
15559 (fun data value -> { data; value })
15560 |> Jsont.Object.mem "data" Asset.ResponseDto.jsont ~enc:(fun r -> r.data)
15561 |> Jsont.Object.mem "value" Jsont.string ~enc:(fun r -> r.value)
15562 |> Jsont.Object.skip_unknown
15563 |> Jsont.Object.finish
15564 end
15565
15566 module ResponseDto = struct
15567 include Types.ResponseDto
15568
15569 let v ~field_name ~items () = { field_name; items }
15570
15571 let field_name t = t.field_name
15572 let items t = t.items
15573
15574 let jsont : t Jsont.t =
15575 Jsont.Object.map ~kind:"SearchExploreResponseDto"
15576 (fun field_name items -> { field_name; items })
15577 |> Jsont.Object.mem "fieldName" Jsont.string ~enc:(fun r -> r.field_name)
15578 |> Jsont.Object.mem "items" (Jsont.list Item.jsont) ~enc:(fun r -> r.items)
15579 |> Jsont.Object.skip_unknown
15580 |> Jsont.Object.finish
15581 end
15582
15583 (** Retrieve explore data
15584
15585 Retrieve data for the explore section, such as popular people and places. *)
15586 let get_explore_data client () =
15587 let op_name = "get_explore_data" in
15588 let url_path = "/search/explore" in
15589 let query = "" in
15590 let url = client.base_url ^ url_path ^ query in
15591 let response =
15592 try Requests.get client.session url
15593 with Eio.Io _ as ex ->
15594 let bt = Printexc.get_raw_backtrace () in
15595 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15596 in
15597 if Requests.Response.ok response then
15598 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15599 else
15600 let body = Requests.Response.text response in
15601 let parsed_body =
15602 match Jsont_bytesrw.decode_string Jsont.json body with
15603 | Ok json -> Some (Openapi.Runtime.Json json)
15604 | Error _ -> Some (Openapi.Runtime.Raw body)
15605 in
15606 raise (Openapi.Runtime.Api_error {
15607 operation = op_name;
15608 method_ = "GET";
15609 url;
15610 status = Requests.Response.status_code response;
15611 body;
15612 parsed_body;
15613 })
15614end
15615
15616module SearchAsset = struct
15617 module Types = struct
15618 module ResponseDto = struct
15619 type t = {
15620 count : int;
15621 facets : SearchFacet.ResponseDto.t list;
15622 items : Asset.ResponseDto.t list;
15623 next_page : string option;
15624 total : int;
15625 }
15626 end
15627 end
15628
15629 module ResponseDto = struct
15630 include Types.ResponseDto
15631
15632 let v ~count ~facets ~items ~total ?next_page () = { count; facets; items; next_page; total }
15633
15634 let count t = t.count
15635 let facets t = t.facets
15636 let items t = t.items
15637 let next_page t = t.next_page
15638 let total t = t.total
15639
15640 let jsont : t Jsont.t =
15641 Jsont.Object.map ~kind:"SearchAssetResponseDto"
15642 (fun count facets items next_page total -> { count; facets; items; next_page; total })
15643 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
15644 |> Jsont.Object.mem "facets" (Jsont.list SearchFacet.ResponseDto.jsont) ~enc:(fun r -> r.facets)
15645 |> Jsont.Object.mem "items" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.items)
15646 |> Jsont.Object.mem "nextPage" Openapi.Runtime.nullable_string
15647 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.next_page)
15648 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
15649 |> Jsont.Object.skip_unknown
15650 |> Jsont.Object.finish
15651 end
15652end
15653
15654module Memory = struct
15655 module Types = struct
15656 module UpdateDto = struct
15657 type t = {
15658 is_saved : bool option;
15659 memory_at : Ptime.t option;
15660 seen_at : Ptime.t option;
15661 }
15662 end
15663
15664 module Type = struct
15665 type t = [
15666 | `On_this_day
15667 ]
15668 end
15669
15670 module ResponseDto = struct
15671 type t = {
15672 assets : Asset.ResponseDto.t list;
15673 created_at : Ptime.t;
15674 data : OnThisDay.Dto.t;
15675 deleted_at : Ptime.t option;
15676 hide_at : Ptime.t option;
15677 id : string;
15678 is_saved : bool;
15679 memory_at : Ptime.t;
15680 owner_id : string;
15681 seen_at : Ptime.t option;
15682 show_at : Ptime.t option;
15683 type_ : Type.t;
15684 updated_at : Ptime.t;
15685 }
15686 end
15687
15688 module CreateDto = struct
15689 type t = {
15690 asset_ids : string list option;
15691 data : OnThisDay.Dto.t;
15692 is_saved : bool option;
15693 memory_at : Ptime.t;
15694 seen_at : Ptime.t option;
15695 type_ : Type.t;
15696 }
15697 end
15698 end
15699
15700 module UpdateDto = struct
15701 include Types.UpdateDto
15702
15703 let v ?is_saved ?memory_at ?seen_at () = { is_saved; memory_at; seen_at }
15704
15705 let is_saved t = t.is_saved
15706 let memory_at t = t.memory_at
15707 let seen_at t = t.seen_at
15708
15709 let jsont : t Jsont.t =
15710 Jsont.Object.map ~kind:"MemoryUpdateDto"
15711 (fun is_saved memory_at seen_at -> { is_saved; memory_at; seen_at })
15712 |> Jsont.Object.opt_mem "isSaved" Jsont.bool ~enc:(fun r -> r.is_saved)
15713 |> Jsont.Object.opt_mem "memoryAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.memory_at)
15714 |> Jsont.Object.opt_mem "seenAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.seen_at)
15715 |> Jsont.Object.skip_unknown
15716 |> Jsont.Object.finish
15717 end
15718
15719 module Type = struct
15720 include Types.Type
15721
15722 let jsont : t Jsont.t =
15723 Jsont.map Jsont.string ~kind:"MemoryType"
15724 ~dec:(function
15725 | "on_this_day" -> `On_this_day
15726 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
15727 ~enc:(function
15728 | `On_this_day -> "on_this_day")
15729 end
15730
15731 module ResponseDto = struct
15732 include Types.ResponseDto
15733
15734 let v ~assets ~created_at ~data ~id ~is_saved ~memory_at ~owner_id ~type_ ~updated_at ?deleted_at ?hide_at ?seen_at ?show_at () = { assets; created_at; data; deleted_at; hide_at; id; is_saved; memory_at; owner_id; seen_at; show_at; type_; updated_at }
15735
15736 let assets t = t.assets
15737 let created_at t = t.created_at
15738 let data t = t.data
15739 let deleted_at t = t.deleted_at
15740 let hide_at t = t.hide_at
15741 let id t = t.id
15742 let is_saved t = t.is_saved
15743 let memory_at t = t.memory_at
15744 let owner_id t = t.owner_id
15745 let seen_at t = t.seen_at
15746 let show_at t = t.show_at
15747 let type_ t = t.type_
15748 let updated_at t = t.updated_at
15749
15750 let jsont : t Jsont.t =
15751 Jsont.Object.map ~kind:"MemoryResponseDto"
15752 (fun assets created_at data deleted_at hide_at id is_saved memory_at owner_id seen_at show_at type_ updated_at -> { assets; created_at; data; deleted_at; hide_at; id; is_saved; memory_at; owner_id; seen_at; show_at; type_; updated_at })
15753 |> Jsont.Object.mem "assets" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.assets)
15754 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
15755 |> Jsont.Object.mem "data" OnThisDay.Dto.jsont ~enc:(fun r -> r.data)
15756 |> Jsont.Object.opt_mem "deletedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.deleted_at)
15757 |> Jsont.Object.opt_mem "hideAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.hide_at)
15758 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
15759 |> Jsont.Object.mem "isSaved" Jsont.bool ~enc:(fun r -> r.is_saved)
15760 |> Jsont.Object.mem "memoryAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.memory_at)
15761 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
15762 |> Jsont.Object.opt_mem "seenAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.seen_at)
15763 |> Jsont.Object.opt_mem "showAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.show_at)
15764 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
15765 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
15766 |> Jsont.Object.skip_unknown
15767 |> Jsont.Object.finish
15768 end
15769
15770 module CreateDto = struct
15771 include Types.CreateDto
15772
15773 let v ~data ~memory_at ~type_ ?asset_ids ?is_saved ?seen_at () = { asset_ids; data; is_saved; memory_at; seen_at; type_ }
15774
15775 let asset_ids t = t.asset_ids
15776 let data t = t.data
15777 let is_saved t = t.is_saved
15778 let memory_at t = t.memory_at
15779 let seen_at t = t.seen_at
15780 let type_ t = t.type_
15781
15782 let jsont : t Jsont.t =
15783 Jsont.Object.map ~kind:"MemoryCreateDto"
15784 (fun asset_ids data is_saved memory_at seen_at type_ -> { asset_ids; data; is_saved; memory_at; seen_at; type_ })
15785 |> Jsont.Object.opt_mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
15786 |> Jsont.Object.mem "data" OnThisDay.Dto.jsont ~enc:(fun r -> r.data)
15787 |> Jsont.Object.opt_mem "isSaved" Jsont.bool ~enc:(fun r -> r.is_saved)
15788 |> Jsont.Object.mem "memoryAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.memory_at)
15789 |> Jsont.Object.opt_mem "seenAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.seen_at)
15790 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
15791 |> Jsont.Object.skip_unknown
15792 |> Jsont.Object.finish
15793 end
15794
15795 (** Retrieve memories
15796
15797 Retrieve a list of memories. Memories are sorted descending by creation date by default, although they can also be sorted in ascending order, or randomly.
15798 @param size Number of memories to return
15799 *)
15800 let search_memories ?for_ ?is_saved ?is_trashed ?order ?size ?type_ client () =
15801 let op_name = "search_memories" in
15802 let url_path = "/memories" in
15803 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"for" ~value:for_; Openapi.Runtime.Query.optional ~key:"isSaved" ~value:is_saved; Openapi.Runtime.Query.optional ~key:"isTrashed" ~value:is_trashed; Openapi.Runtime.Query.optional ~key:"order" ~value:order; Openapi.Runtime.Query.optional ~key:"size" ~value:size; Openapi.Runtime.Query.optional ~key:"type" ~value:type_]) in
15804 let url = client.base_url ^ url_path ^ query in
15805 let response =
15806 try Requests.get client.session url
15807 with Eio.Io _ as ex ->
15808 let bt = Printexc.get_raw_backtrace () in
15809 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15810 in
15811 if Requests.Response.ok response then
15812 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15813 else
15814 let body = Requests.Response.text response in
15815 let parsed_body =
15816 match Jsont_bytesrw.decode_string Jsont.json body with
15817 | Ok json -> Some (Openapi.Runtime.Json json)
15818 | Error _ -> Some (Openapi.Runtime.Raw body)
15819 in
15820 raise (Openapi.Runtime.Api_error {
15821 operation = op_name;
15822 method_ = "GET";
15823 url;
15824 status = Requests.Response.status_code response;
15825 body;
15826 parsed_body;
15827 })
15828
15829 (** Create a memory
15830
15831 Create a new memory by providing a name, description, and a list of asset IDs to include in the memory. *)
15832 let create_memory ~body client () =
15833 let op_name = "create_memory" in
15834 let url_path = "/memories" in
15835 let query = "" in
15836 let url = client.base_url ^ url_path ^ query in
15837 let response =
15838 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
15839 with Eio.Io _ as ex ->
15840 let bt = Printexc.get_raw_backtrace () in
15841 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
15842 in
15843 if Requests.Response.ok response then
15844 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15845 else
15846 let body = Requests.Response.text response in
15847 let parsed_body =
15848 match Jsont_bytesrw.decode_string Jsont.json body with
15849 | Ok json -> Some (Openapi.Runtime.Json json)
15850 | Error _ -> Some (Openapi.Runtime.Raw body)
15851 in
15852 raise (Openapi.Runtime.Api_error {
15853 operation = op_name;
15854 method_ = "POST";
15855 url;
15856 status = Requests.Response.status_code response;
15857 body;
15858 parsed_body;
15859 })
15860
15861 (** Retrieve a memory
15862
15863 Retrieve a specific memory by its ID. *)
15864 let get_memory ~id client () =
15865 let op_name = "get_memory" in
15866 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/memories/{id}" in
15867 let query = "" in
15868 let url = client.base_url ^ url_path ^ query in
15869 let response =
15870 try Requests.get client.session url
15871 with Eio.Io _ as ex ->
15872 let bt = Printexc.get_raw_backtrace () in
15873 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
15874 in
15875 if Requests.Response.ok response then
15876 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15877 else
15878 let body = Requests.Response.text response in
15879 let parsed_body =
15880 match Jsont_bytesrw.decode_string Jsont.json body with
15881 | Ok json -> Some (Openapi.Runtime.Json json)
15882 | Error _ -> Some (Openapi.Runtime.Raw body)
15883 in
15884 raise (Openapi.Runtime.Api_error {
15885 operation = op_name;
15886 method_ = "GET";
15887 url;
15888 status = Requests.Response.status_code response;
15889 body;
15890 parsed_body;
15891 })
15892
15893 (** Update a memory
15894
15895 Update an existing memory by its ID. *)
15896 let update_memory ~id ~body client () =
15897 let op_name = "update_memory" in
15898 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/memories/{id}" in
15899 let query = "" in
15900 let url = client.base_url ^ url_path ^ query in
15901 let response =
15902 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
15903 with Eio.Io _ as ex ->
15904 let bt = Printexc.get_raw_backtrace () in
15905 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
15906 in
15907 if Requests.Response.ok response then
15908 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
15909 else
15910 let body = Requests.Response.text response in
15911 let parsed_body =
15912 match Jsont_bytesrw.decode_string Jsont.json body with
15913 | Ok json -> Some (Openapi.Runtime.Json json)
15914 | Error _ -> Some (Openapi.Runtime.Raw body)
15915 in
15916 raise (Openapi.Runtime.Api_error {
15917 operation = op_name;
15918 method_ = "PUT";
15919 url;
15920 status = Requests.Response.status_code response;
15921 body;
15922 parsed_body;
15923 })
15924end
15925
15926module SyncMemoryV1 = struct
15927 module Types = struct
15928 module T = struct
15929 type t = {
15930 created_at : Ptime.t;
15931 data : Jsont.json;
15932 deleted_at : Ptime.t option;
15933 hide_at : Ptime.t option;
15934 id : string;
15935 is_saved : bool;
15936 memory_at : Ptime.t;
15937 owner_id : string;
15938 seen_at : Ptime.t option;
15939 show_at : Ptime.t option;
15940 type_ : Memory.Type.t;
15941 updated_at : Ptime.t;
15942 }
15943 end
15944 end
15945
15946 module T = struct
15947 include Types.T
15948
15949 let v ~created_at ~data ~id ~is_saved ~memory_at ~owner_id ~type_ ~updated_at ?deleted_at ?hide_at ?seen_at ?show_at () = { created_at; data; deleted_at; hide_at; id; is_saved; memory_at; owner_id; seen_at; show_at; type_; updated_at }
15950
15951 let created_at t = t.created_at
15952 let data t = t.data
15953 let deleted_at t = t.deleted_at
15954 let hide_at t = t.hide_at
15955 let id t = t.id
15956 let is_saved t = t.is_saved
15957 let memory_at t = t.memory_at
15958 let owner_id t = t.owner_id
15959 let seen_at t = t.seen_at
15960 let show_at t = t.show_at
15961 let type_ t = t.type_
15962 let updated_at t = t.updated_at
15963
15964 let jsont : t Jsont.t =
15965 Jsont.Object.map ~kind:"SyncMemoryV1"
15966 (fun created_at data deleted_at hide_at id is_saved memory_at owner_id seen_at show_at type_ updated_at -> { created_at; data; deleted_at; hide_at; id; is_saved; memory_at; owner_id; seen_at; show_at; type_; updated_at })
15967 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
15968 |> Jsont.Object.mem "data" Jsont.json ~enc:(fun r -> r.data)
15969 |> Jsont.Object.mem "deletedAt" Openapi.Runtime.nullable_ptime
15970 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.deleted_at)
15971 |> Jsont.Object.mem "hideAt" Openapi.Runtime.nullable_ptime
15972 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.hide_at)
15973 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
15974 |> Jsont.Object.mem "isSaved" Jsont.bool ~enc:(fun r -> r.is_saved)
15975 |> Jsont.Object.mem "memoryAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.memory_at)
15976 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
15977 |> Jsont.Object.mem "seenAt" Openapi.Runtime.nullable_ptime
15978 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.seen_at)
15979 |> Jsont.Object.mem "showAt" Openapi.Runtime.nullable_ptime
15980 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.show_at)
15981 |> Jsont.Object.mem "type" Memory.Type.jsont ~enc:(fun r -> r.type_)
15982 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
15983 |> Jsont.Object.skip_unknown
15984 |> Jsont.Object.finish
15985 end
15986end
15987
15988module Duplicate = struct
15989 module Types = struct
15990 module ResponseDto = struct
15991 type t = {
15992 assets : Asset.ResponseDto.t list;
15993 duplicate_id : string;
15994 }
15995 end
15996 end
15997
15998 module ResponseDto = struct
15999 include Types.ResponseDto
16000
16001 let v ~assets ~duplicate_id () = { assets; duplicate_id }
16002
16003 let assets t = t.assets
16004 let duplicate_id t = t.duplicate_id
16005
16006 let jsont : t Jsont.t =
16007 Jsont.Object.map ~kind:"DuplicateResponseDto"
16008 (fun assets duplicate_id -> { assets; duplicate_id })
16009 |> Jsont.Object.mem "assets" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.assets)
16010 |> Jsont.Object.mem "duplicateId" Jsont.string ~enc:(fun r -> r.duplicate_id)
16011 |> Jsont.Object.skip_unknown
16012 |> Jsont.Object.finish
16013 end
16014
16015 (** Retrieve duplicates
16016
16017 Retrieve a list of duplicate assets available to the authenticated user. *)
16018 let get_asset_duplicates client () =
16019 let op_name = "get_asset_duplicates" in
16020 let url_path = "/duplicates" in
16021 let query = "" in
16022 let url = client.base_url ^ url_path ^ query in
16023 let response =
16024 try Requests.get client.session url
16025 with Eio.Io _ as ex ->
16026 let bt = Printexc.get_raw_backtrace () in
16027 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
16028 in
16029 if Requests.Response.ok response then
16030 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
16031 else
16032 let body = Requests.Response.text response in
16033 let parsed_body =
16034 match Jsont_bytesrw.decode_string Jsont.json body with
16035 | Ok json -> Some (Openapi.Runtime.Json json)
16036 | Error _ -> Some (Openapi.Runtime.Raw body)
16037 in
16038 raise (Openapi.Runtime.Api_error {
16039 operation = op_name;
16040 method_ = "GET";
16041 url;
16042 status = Requests.Response.status_code response;
16043 body;
16044 parsed_body;
16045 })
16046end
16047
16048module AssetDeltaSync = struct
16049 module Types = struct
16050 module ResponseDto = struct
16051 type t = {
16052 deleted : string list;
16053 needs_full_sync : bool;
16054 upserted : Asset.ResponseDto.t list;
16055 }
16056 end
16057
16058 module Dto = struct
16059 type t = {
16060 updated_after : Ptime.t;
16061 user_ids : string list;
16062 }
16063 end
16064 end
16065
16066 module ResponseDto = struct
16067 include Types.ResponseDto
16068
16069 let v ~deleted ~needs_full_sync ~upserted () = { deleted; needs_full_sync; upserted }
16070
16071 let deleted t = t.deleted
16072 let needs_full_sync t = t.needs_full_sync
16073 let upserted t = t.upserted
16074
16075 let jsont : t Jsont.t =
16076 Jsont.Object.map ~kind:"AssetDeltaSyncResponseDto"
16077 (fun deleted needs_full_sync upserted -> { deleted; needs_full_sync; upserted })
16078 |> Jsont.Object.mem "deleted" (Jsont.list Jsont.string) ~enc:(fun r -> r.deleted)
16079 |> Jsont.Object.mem "needsFullSync" Jsont.bool ~enc:(fun r -> r.needs_full_sync)
16080 |> Jsont.Object.mem "upserted" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.upserted)
16081 |> Jsont.Object.skip_unknown
16082 |> Jsont.Object.finish
16083 end
16084
16085 module Dto = struct
16086 include Types.Dto
16087
16088 let v ~updated_after ~user_ids () = { updated_after; user_ids }
16089
16090 let updated_after t = t.updated_after
16091 let user_ids t = t.user_ids
16092
16093 let jsont : t Jsont.t =
16094 Jsont.Object.map ~kind:"AssetDeltaSyncDto"
16095 (fun updated_after user_ids -> { updated_after; user_ids })
16096 |> Jsont.Object.mem "updatedAfter" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_after)
16097 |> Jsont.Object.mem "userIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.user_ids)
16098 |> Jsont.Object.skip_unknown
16099 |> Jsont.Object.finish
16100 end
16101
16102 (** Get delta sync for user
16103
16104 Retrieve changed assets since the last sync for the authenticated user. *)
16105 let get_delta_sync ~body client () =
16106 let op_name = "get_delta_sync" in
16107 let url_path = "/sync/delta-sync" in
16108 let query = "" in
16109 let url = client.base_url ^ url_path ^ query in
16110 let response =
16111 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
16112 with Eio.Io _ as ex ->
16113 let bt = Printexc.get_raw_backtrace () in
16114 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
16115 in
16116 if Requests.Response.ok response then
16117 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
16118 else
16119 let body = Requests.Response.text response in
16120 let parsed_body =
16121 match Jsont_bytesrw.decode_string Jsont.json body with
16122 | Ok json -> Some (Openapi.Runtime.Json json)
16123 | Error _ -> Some (Openapi.Runtime.Raw body)
16124 in
16125 raise (Openapi.Runtime.Api_error {
16126 operation = op_name;
16127 method_ = "POST";
16128 url;
16129 status = Requests.Response.status_code response;
16130 body;
16131 parsed_body;
16132 })
16133end
16134
16135module AssetFaceUpdate = struct
16136 module Types = struct
16137 module Item = struct
16138 type t = {
16139 asset_id : string;
16140 person_id : string;
16141 }
16142 end
16143 end
16144
16145 module Item = struct
16146 include Types.Item
16147
16148 let v ~asset_id ~person_id () = { asset_id; person_id }
16149
16150 let asset_id t = t.asset_id
16151 let person_id t = t.person_id
16152
16153 let jsont : t Jsont.t =
16154 Jsont.Object.map ~kind:"AssetFaceUpdateItem"
16155 (fun asset_id person_id -> { asset_id; person_id })
16156 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
16157 |> Jsont.Object.mem "personId" Jsont.string ~enc:(fun r -> r.person_id)
16158 |> Jsont.Object.skip_unknown
16159 |> Jsont.Object.finish
16160 end
16161end
16162
16163module AssetFaceDelete = struct
16164 module Types = struct
16165 module Dto = struct
16166 type t = {
16167 force : bool;
16168 }
16169 end
16170 end
16171
16172 module Dto = struct
16173 include Types.Dto
16174
16175 let v ~force () = { force }
16176
16177 let force t = t.force
16178
16179 let jsont : t Jsont.t =
16180 Jsont.Object.map ~kind:"AssetFaceDeleteDto"
16181 (fun force -> { force })
16182 |> Jsont.Object.mem "force" Jsont.bool ~enc:(fun r -> r.force)
16183 |> Jsont.Object.skip_unknown
16184 |> Jsont.Object.finish
16185 end
16186end
16187
16188module AssetEditActionList = struct
16189 module Types = struct
16190 module Dto = struct
16191 type t = {
16192 edits : Jsont.json list; (** list of edits *)
16193 }
16194 end
16195 end
16196
16197 module Dto = struct
16198 include Types.Dto
16199
16200 let v ~edits () = { edits }
16201
16202 let edits t = t.edits
16203
16204 let jsont : t Jsont.t =
16205 Jsont.Object.map ~kind:"AssetEditActionListDto"
16206 (fun edits -> { edits })
16207 |> Jsont.Object.mem "edits" (Openapi.Runtime.validated_list ~min_items:1 Jsont.json) ~enc:(fun r -> r.edits)
16208 |> Jsont.Object.skip_unknown
16209 |> Jsont.Object.finish
16210 end
16211end
16212
16213module AssetEdits = struct
16214 module Types = struct
16215 module Dto = struct
16216 type t = {
16217 asset_id : string;
16218 edits : Jsont.json list; (** list of edits *)
16219 }
16220 end
16221 end
16222
16223 module Dto = struct
16224 include Types.Dto
16225
16226 let v ~asset_id ~edits () = { asset_id; edits }
16227
16228 let asset_id t = t.asset_id
16229 let edits t = t.edits
16230
16231 let jsont : t Jsont.t =
16232 Jsont.Object.map ~kind:"AssetEditsDto"
16233 (fun asset_id edits -> { asset_id; edits })
16234 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
16235 |> Jsont.Object.mem "edits" (Openapi.Runtime.validated_list ~min_items:1 Jsont.json) ~enc:(fun r -> r.edits)
16236 |> Jsont.Object.skip_unknown
16237 |> Jsont.Object.finish
16238 end
16239
16240 (** Retrieve edits for an existing asset
16241
16242 Retrieve a series of edit actions (crop, rotate, mirror) associated with the specified asset. *)
16243 let get_asset_edits ~id client () =
16244 let op_name = "get_asset_edits" in
16245 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/edits" in
16246 let query = "" in
16247 let url = client.base_url ^ url_path ^ query in
16248 let response =
16249 try Requests.get client.session url
16250 with Eio.Io _ as ex ->
16251 let bt = Printexc.get_raw_backtrace () in
16252 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
16253 in
16254 if Requests.Response.ok response then
16255 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
16256 else
16257 let body = Requests.Response.text response in
16258 let parsed_body =
16259 match Jsont_bytesrw.decode_string Jsont.json body with
16260 | Ok json -> Some (Openapi.Runtime.Json json)
16261 | Error _ -> Some (Openapi.Runtime.Raw body)
16262 in
16263 raise (Openapi.Runtime.Api_error {
16264 operation = op_name;
16265 method_ = "GET";
16266 url;
16267 status = Requests.Response.status_code response;
16268 body;
16269 parsed_body;
16270 })
16271
16272 (** Apply edits to an existing asset
16273
16274 Apply a series of edit actions (crop, rotate, mirror) to the specified asset. *)
16275 let edit_asset ~id ~body client () =
16276 let op_name = "edit_asset" in
16277 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/edits" in
16278 let query = "" in
16279 let url = client.base_url ^ url_path ^ query in
16280 let response =
16281 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetEditActionList.Dto.jsont body)) url
16282 with Eio.Io _ as ex ->
16283 let bt = Printexc.get_raw_backtrace () in
16284 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
16285 in
16286 if Requests.Response.ok response then
16287 Openapi.Runtime.Json.decode_json_exn Dto.jsont (Requests.Response.json response)
16288 else
16289 let body = Requests.Response.text response in
16290 let parsed_body =
16291 match Jsont_bytesrw.decode_string Jsont.json body with
16292 | Ok json -> Some (Openapi.Runtime.Json json)
16293 | Error _ -> Some (Openapi.Runtime.Raw body)
16294 in
16295 raise (Openapi.Runtime.Api_error {
16296 operation = op_name;
16297 method_ = "PUT";
16298 url;
16299 status = Requests.Response.status_code response;
16300 body;
16301 parsed_body;
16302 })
16303end
16304
16305module AssetEditAction = struct
16306 module Types = struct
16307 module T = struct
16308 type t = [
16309 | `Crop
16310 | `Rotate
16311 | `Mirror
16312 ]
16313 end
16314 end
16315
16316 module T = struct
16317 include Types.T
16318
16319 let jsont : t Jsont.t =
16320 Jsont.map Jsont.string ~kind:"AssetEditAction"
16321 ~dec:(function
16322 | "crop" -> `Crop
16323 | "rotate" -> `Rotate
16324 | "mirror" -> `Mirror
16325 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
16326 ~enc:(function
16327 | `Crop -> "crop"
16328 | `Rotate -> "rotate"
16329 | `Mirror -> "mirror")
16330 end
16331end
16332
16333module AssetEditActionRotate = struct
16334 module Types = struct
16335 module T = struct
16336 type t = {
16337 action : AssetEditAction.T.t;
16338 parameters : RotateParameters.T.t;
16339 }
16340 end
16341 end
16342
16343 module T = struct
16344 include Types.T
16345
16346 let v ~action ~parameters () = { action; parameters }
16347
16348 let action t = t.action
16349 let parameters t = t.parameters
16350
16351 let jsont : t Jsont.t =
16352 Jsont.Object.map ~kind:"AssetEditActionRotate"
16353 (fun action parameters -> { action; parameters })
16354 |> Jsont.Object.mem "action" AssetEditAction.T.jsont ~enc:(fun r -> r.action)
16355 |> Jsont.Object.mem "parameters" RotateParameters.T.jsont ~enc:(fun r -> r.parameters)
16356 |> Jsont.Object.skip_unknown
16357 |> Jsont.Object.finish
16358 end
16359end
16360
16361module AssetEditActionMirror = struct
16362 module Types = struct
16363 module T = struct
16364 type t = {
16365 action : AssetEditAction.T.t;
16366 parameters : MirrorParameters.T.t;
16367 }
16368 end
16369 end
16370
16371 module T = struct
16372 include Types.T
16373
16374 let v ~action ~parameters () = { action; parameters }
16375
16376 let action t = t.action
16377 let parameters t = t.parameters
16378
16379 let jsont : t Jsont.t =
16380 Jsont.Object.map ~kind:"AssetEditActionMirror"
16381 (fun action parameters -> { action; parameters })
16382 |> Jsont.Object.mem "action" AssetEditAction.T.jsont ~enc:(fun r -> r.action)
16383 |> Jsont.Object.mem "parameters" MirrorParameters.T.jsont ~enc:(fun r -> r.parameters)
16384 |> Jsont.Object.skip_unknown
16385 |> Jsont.Object.finish
16386 end
16387end
16388
16389module AssetEditActionCrop = struct
16390 module Types = struct
16391 module T = struct
16392 type t = {
16393 action : AssetEditAction.T.t;
16394 parameters : CropParameters.T.t;
16395 }
16396 end
16397 end
16398
16399 module T = struct
16400 include Types.T
16401
16402 let v ~action ~parameters () = { action; parameters }
16403
16404 let action t = t.action
16405 let parameters t = t.parameters
16406
16407 let jsont : t Jsont.t =
16408 Jsont.Object.map ~kind:"AssetEditActionCrop"
16409 (fun action parameters -> { action; parameters })
16410 |> Jsont.Object.mem "action" AssetEditAction.T.jsont ~enc:(fun r -> r.action)
16411 |> Jsont.Object.mem "parameters" CropParameters.T.jsont ~enc:(fun r -> r.parameters)
16412 |> Jsont.Object.skip_unknown
16413 |> Jsont.Object.finish
16414 end
16415end
16416
16417module AssetCopy = struct
16418 module Types = struct
16419 module Dto = struct
16420 type t = {
16421 albums : bool;
16422 favorite : bool;
16423 shared_links : bool;
16424 sidecar : bool;
16425 source_id : string;
16426 stack : bool;
16427 target_id : string;
16428 }
16429 end
16430 end
16431
16432 module Dto = struct
16433 include Types.Dto
16434
16435 let v ~source_id ~target_id ?(albums=true) ?(favorite=true) ?(shared_links=true) ?(sidecar=true) ?(stack=true) () = { albums; favorite; shared_links; sidecar; source_id; stack; target_id }
16436
16437 let albums t = t.albums
16438 let favorite t = t.favorite
16439 let shared_links t = t.shared_links
16440 let sidecar t = t.sidecar
16441 let source_id t = t.source_id
16442 let stack t = t.stack
16443 let target_id t = t.target_id
16444
16445 let jsont : t Jsont.t =
16446 Jsont.Object.map ~kind:"AssetCopyDto"
16447 (fun albums favorite shared_links sidecar source_id stack target_id -> { albums; favorite; shared_links; sidecar; source_id; stack; target_id })
16448 |> Jsont.Object.mem "albums" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.albums)
16449 |> Jsont.Object.mem "favorite" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.favorite)
16450 |> Jsont.Object.mem "sharedLinks" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.shared_links)
16451 |> Jsont.Object.mem "sidecar" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.sidecar)
16452 |> Jsont.Object.mem "sourceId" Jsont.string ~enc:(fun r -> r.source_id)
16453 |> Jsont.Object.mem "stack" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.stack)
16454 |> Jsont.Object.mem "targetId" Jsont.string ~enc:(fun r -> r.target_id)
16455 |> Jsont.Object.skip_unknown
16456 |> Jsont.Object.finish
16457 end
16458end
16459
16460module AssetBulkUploadCheck = struct
16461 module Types = struct
16462 module Result = struct
16463 type t = {
16464 action : string;
16465 asset_id : string option;
16466 id : string;
16467 is_trashed : bool option;
16468 reason : string option;
16469 }
16470 end
16471
16472 module ResponseDto = struct
16473 type t = {
16474 results : Result.t list;
16475 }
16476 end
16477
16478 module Item = struct
16479 type t = {
16480 checksum : string; (** base64 or hex encoded sha1 hash *)
16481 id : string;
16482 }
16483 end
16484
16485 module Dto = struct
16486 type t = {
16487 assets : Item.t list;
16488 }
16489 end
16490 end
16491
16492 module Result = struct
16493 include Types.Result
16494
16495 let v ~action ~id ?asset_id ?is_trashed ?reason () = { action; asset_id; id; is_trashed; reason }
16496
16497 let action t = t.action
16498 let asset_id t = t.asset_id
16499 let id t = t.id
16500 let is_trashed t = t.is_trashed
16501 let reason t = t.reason
16502
16503 let jsont : t Jsont.t =
16504 Jsont.Object.map ~kind:"AssetBulkUploadCheckResult"
16505 (fun action asset_id id is_trashed reason -> { action; asset_id; id; is_trashed; reason })
16506 |> Jsont.Object.mem "action" Jsont.string ~enc:(fun r -> r.action)
16507 |> Jsont.Object.opt_mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
16508 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
16509 |> Jsont.Object.opt_mem "isTrashed" Jsont.bool ~enc:(fun r -> r.is_trashed)
16510 |> Jsont.Object.opt_mem "reason" Jsont.string ~enc:(fun r -> r.reason)
16511 |> Jsont.Object.skip_unknown
16512 |> Jsont.Object.finish
16513 end
16514
16515 module ResponseDto = struct
16516 include Types.ResponseDto
16517
16518 let v ~results () = { results }
16519
16520 let results t = t.results
16521
16522 let jsont : t Jsont.t =
16523 Jsont.Object.map ~kind:"AssetBulkUploadCheckResponseDto"
16524 (fun results -> { results })
16525 |> Jsont.Object.mem "results" (Jsont.list Result.jsont) ~enc:(fun r -> r.results)
16526 |> Jsont.Object.skip_unknown
16527 |> Jsont.Object.finish
16528 end
16529
16530 module Item = struct
16531 include Types.Item
16532
16533 let v ~checksum ~id () = { checksum; id }
16534
16535 let checksum t = t.checksum
16536 let id t = t.id
16537
16538 let jsont : t Jsont.t =
16539 Jsont.Object.map ~kind:"AssetBulkUploadCheckItem"
16540 (fun checksum id -> { checksum; id })
16541 |> Jsont.Object.mem "checksum" Jsont.string ~enc:(fun r -> r.checksum)
16542 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
16543 |> Jsont.Object.skip_unknown
16544 |> Jsont.Object.finish
16545 end
16546
16547 module Dto = struct
16548 include Types.Dto
16549
16550 let v ~assets () = { assets }
16551
16552 let assets t = t.assets
16553
16554 let jsont : t Jsont.t =
16555 Jsont.Object.map ~kind:"AssetBulkUploadCheckDto"
16556 (fun assets -> { assets })
16557 |> Jsont.Object.mem "assets" (Jsont.list Item.jsont) ~enc:(fun r -> r.assets)
16558 |> Jsont.Object.skip_unknown
16559 |> Jsont.Object.finish
16560 end
16561
16562 (** Check bulk upload
16563
16564 Determine which assets have already been uploaded to the server based on their SHA1 checksums. *)
16565 let check_bulk_upload ~body client () =
16566 let op_name = "check_bulk_upload" in
16567 let url_path = "/assets/bulk-upload-check" in
16568 let query = "" in
16569 let url = client.base_url ^ url_path ^ query in
16570 let response =
16571 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Dto.jsont body)) url
16572 with Eio.Io _ as ex ->
16573 let bt = Printexc.get_raw_backtrace () in
16574 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
16575 in
16576 if Requests.Response.ok response then
16577 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
16578 else
16579 let body = Requests.Response.text response in
16580 let parsed_body =
16581 match Jsont_bytesrw.decode_string Jsont.json body with
16582 | Ok json -> Some (Openapi.Runtime.Json json)
16583 | Error _ -> Some (Openapi.Runtime.Raw body)
16584 in
16585 raise (Openapi.Runtime.Api_error {
16586 operation = op_name;
16587 method_ = "POST";
16588 url;
16589 status = Requests.Response.status_code response;
16590 body;
16591 parsed_body;
16592 })
16593end
16594
16595module AssetBulkDelete = struct
16596 module Types = struct
16597 module Dto = struct
16598 type t = {
16599 force : bool option;
16600 ids : string list;
16601 }
16602 end
16603 end
16604
16605 module Dto = struct
16606 include Types.Dto
16607
16608 let v ~ids ?force () = { force; ids }
16609
16610 let force t = t.force
16611 let ids t = t.ids
16612
16613 let jsont : t Jsont.t =
16614 Jsont.Object.map ~kind:"AssetBulkDeleteDto"
16615 (fun force ids -> { force; ids })
16616 |> Jsont.Object.opt_mem "force" Jsont.bool ~enc:(fun r -> r.force)
16617 |> Jsont.Object.mem "ids" (Jsont.list Jsont.string) ~enc:(fun r -> r.ids)
16618 |> Jsont.Object.skip_unknown
16619 |> Jsont.Object.finish
16620 end
16621end
16622
16623module AlbumUserRole = struct
16624 module Types = struct
16625 module T = struct
16626 type t = [
16627 | `Editor
16628 | `Viewer
16629 ]
16630 end
16631 end
16632
16633 module T = struct
16634 include Types.T
16635
16636 let jsont : t Jsont.t =
16637 Jsont.map Jsont.string ~kind:"AlbumUserRole"
16638 ~dec:(function
16639 | "editor" -> `Editor
16640 | "viewer" -> `Viewer
16641 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
16642 ~enc:(function
16643 | `Editor -> "editor"
16644 | `Viewer -> "viewer")
16645 end
16646end
16647
16648module UpdateAlbumUser = struct
16649 module Types = struct
16650 module Dto = struct
16651 type t = {
16652 role : AlbumUserRole.T.t;
16653 }
16654 end
16655 end
16656
16657 module Dto = struct
16658 include Types.Dto
16659
16660 let v ~role () = { role }
16661
16662 let role t = t.role
16663
16664 let jsont : t Jsont.t =
16665 Jsont.Object.map ~kind:"UpdateAlbumUserDto"
16666 (fun role -> { role })
16667 |> Jsont.Object.mem "role" AlbumUserRole.T.jsont ~enc:(fun r -> r.role)
16668 |> Jsont.Object.skip_unknown
16669 |> Jsont.Object.finish
16670 end
16671end
16672
16673module SyncAlbumUserV1 = struct
16674 module Types = struct
16675 module T = struct
16676 type t = {
16677 album_id : string;
16678 role : AlbumUserRole.T.t;
16679 user_id : string;
16680 }
16681 end
16682 end
16683
16684 module T = struct
16685 include Types.T
16686
16687 let v ~album_id ~role ~user_id () = { album_id; role; user_id }
16688
16689 let album_id t = t.album_id
16690 let role t = t.role
16691 let user_id t = t.user_id
16692
16693 let jsont : t Jsont.t =
16694 Jsont.Object.map ~kind:"SyncAlbumUserV1"
16695 (fun album_id role user_id -> { album_id; role; user_id })
16696 |> Jsont.Object.mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
16697 |> Jsont.Object.mem "role" AlbumUserRole.T.jsont ~enc:(fun r -> r.role)
16698 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
16699 |> Jsont.Object.skip_unknown
16700 |> Jsont.Object.finish
16701 end
16702end
16703
16704module AlbumUserAdd = struct
16705 module Types = struct
16706 module Dto = struct
16707 type t = {
16708 role : AlbumUserRole.T.t;
16709 user_id : string;
16710 }
16711 end
16712 end
16713
16714 module Dto = struct
16715 include Types.Dto
16716
16717 let v ~user_id ?(role=`Editor) () = { role; user_id }
16718
16719 let role t = t.role
16720 let user_id t = t.user_id
16721
16722 let jsont : t Jsont.t =
16723 Jsont.Object.map ~kind:"AlbumUserAddDto"
16724 (fun role user_id -> { role; user_id })
16725 |> Jsont.Object.mem "role" AlbumUserRole.T.jsont ~dec_absent:`Editor ~enc:(fun r -> r.role)
16726 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
16727 |> Jsont.Object.skip_unknown
16728 |> Jsont.Object.finish
16729 end
16730end
16731
16732module AddUsers = struct
16733 module Types = struct
16734 module Dto = struct
16735 type t = {
16736 album_users : AlbumUserAdd.Dto.t list;
16737 }
16738 end
16739 end
16740
16741 module Dto = struct
16742 include Types.Dto
16743
16744 let v ~album_users () = { album_users }
16745
16746 let album_users t = t.album_users
16747
16748 let jsont : t Jsont.t =
16749 Jsont.Object.map ~kind:"AddUsersDto"
16750 (fun album_users -> { album_users })
16751 |> Jsont.Object.mem "albumUsers" (Openapi.Runtime.validated_list ~min_items:1 AlbumUserAdd.Dto.jsont) ~enc:(fun r -> r.album_users)
16752 |> Jsont.Object.skip_unknown
16753 |> Jsont.Object.finish
16754 end
16755end
16756
16757module AlbumUser = struct
16758 module Types = struct
16759 module ResponseDto = struct
16760 type t = {
16761 role : AlbumUserRole.T.t;
16762 user : User.ResponseDto.t;
16763 }
16764 end
16765
16766 module CreateDto = struct
16767 type t = {
16768 role : AlbumUserRole.T.t;
16769 user_id : string;
16770 }
16771 end
16772 end
16773
16774 module ResponseDto = struct
16775 include Types.ResponseDto
16776
16777 let v ~role ~user () = { role; user }
16778
16779 let role t = t.role
16780 let user t = t.user
16781
16782 let jsont : t Jsont.t =
16783 Jsont.Object.map ~kind:"AlbumUserResponseDto"
16784 (fun role user -> { role; user })
16785 |> Jsont.Object.mem "role" AlbumUserRole.T.jsont ~enc:(fun r -> r.role)
16786 |> Jsont.Object.mem "user" User.ResponseDto.jsont ~enc:(fun r -> r.user)
16787 |> Jsont.Object.skip_unknown
16788 |> Jsont.Object.finish
16789 end
16790
16791 module CreateDto = struct
16792 include Types.CreateDto
16793
16794 let v ~role ~user_id () = { role; user_id }
16795
16796 let role t = t.role
16797 let user_id t = t.user_id
16798
16799 let jsont : t Jsont.t =
16800 Jsont.Object.map ~kind:"AlbumUserCreateDto"
16801 (fun role user_id -> { role; user_id })
16802 |> Jsont.Object.mem "role" AlbumUserRole.T.jsont ~enc:(fun r -> r.role)
16803 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
16804 |> Jsont.Object.skip_unknown
16805 |> Jsont.Object.finish
16806 end
16807end
16808
16809module CreateAlbum = struct
16810 module Types = struct
16811 module Dto = struct
16812 type t = {
16813 album_name : string;
16814 album_users : AlbumUser.CreateDto.t list option;
16815 asset_ids : string list option;
16816 description : string option;
16817 }
16818 end
16819 end
16820
16821 module Dto = struct
16822 include Types.Dto
16823
16824 let v ~album_name ?album_users ?asset_ids ?description () = { album_name; album_users; asset_ids; description }
16825
16826 let album_name t = t.album_name
16827 let album_users t = t.album_users
16828 let asset_ids t = t.asset_ids
16829 let description t = t.description
16830
16831 let jsont : t Jsont.t =
16832 Jsont.Object.map ~kind:"CreateAlbumDto"
16833 (fun album_name album_users asset_ids description -> { album_name; album_users; asset_ids; description })
16834 |> Jsont.Object.mem "albumName" Jsont.string ~enc:(fun r -> r.album_name)
16835 |> Jsont.Object.opt_mem "albumUsers" (Jsont.list AlbumUser.CreateDto.jsont) ~enc:(fun r -> r.album_users)
16836 |> Jsont.Object.opt_mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
16837 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
16838 |> Jsont.Object.skip_unknown
16839 |> Jsont.Object.finish
16840 end
16841end
16842
16843module Album = struct
16844 module Types = struct
16845 module ResponseDto = struct
16846 type t = {
16847 album_name : string;
16848 album_thumbnail_asset_id : string option;
16849 album_users : AlbumUser.ResponseDto.t list;
16850 asset_count : int;
16851 assets : Asset.ResponseDto.t list;
16852 contributor_counts : ContributorCount.ResponseDto.t list option;
16853 created_at : Ptime.t;
16854 description : string;
16855 end_date : Ptime.t option;
16856 has_shared_link : bool;
16857 id : string;
16858 is_activity_enabled : bool;
16859 last_modified_asset_timestamp : Ptime.t option;
16860 order : AssetOrder.T.t option;
16861 owner : User.ResponseDto.t;
16862 owner_id : string;
16863 shared : bool;
16864 start_date : Ptime.t option;
16865 updated_at : Ptime.t;
16866 }
16867 end
16868 end
16869
16870 module ResponseDto = struct
16871 include Types.ResponseDto
16872
16873 let v ~album_name ~album_users ~asset_count ~assets ~created_at ~description ~has_shared_link ~id ~is_activity_enabled ~owner ~owner_id ~shared ~updated_at ?album_thumbnail_asset_id ?contributor_counts ?end_date ?last_modified_asset_timestamp ?order ?start_date () = { album_name; album_thumbnail_asset_id; album_users; asset_count; assets; contributor_counts; created_at; description; end_date; has_shared_link; id; is_activity_enabled; last_modified_asset_timestamp; order; owner; owner_id; shared; start_date; updated_at }
16874
16875 let album_name t = t.album_name
16876 let album_thumbnail_asset_id t = t.album_thumbnail_asset_id
16877 let album_users t = t.album_users
16878 let asset_count t = t.asset_count
16879 let assets t = t.assets
16880 let contributor_counts t = t.contributor_counts
16881 let created_at t = t.created_at
16882 let description t = t.description
16883 let end_date t = t.end_date
16884 let has_shared_link t = t.has_shared_link
16885 let id t = t.id
16886 let is_activity_enabled t = t.is_activity_enabled
16887 let last_modified_asset_timestamp t = t.last_modified_asset_timestamp
16888 let order t = t.order
16889 let owner t = t.owner
16890 let owner_id t = t.owner_id
16891 let shared t = t.shared
16892 let start_date t = t.start_date
16893 let updated_at t = t.updated_at
16894
16895 let jsont : t Jsont.t =
16896 Jsont.Object.map ~kind:"AlbumResponseDto"
16897 (fun album_name album_thumbnail_asset_id album_users asset_count assets contributor_counts created_at description end_date has_shared_link id is_activity_enabled last_modified_asset_timestamp order owner owner_id shared start_date updated_at -> { album_name; album_thumbnail_asset_id; album_users; asset_count; assets; contributor_counts; created_at; description; end_date; has_shared_link; id; is_activity_enabled; last_modified_asset_timestamp; order; owner; owner_id; shared; start_date; updated_at })
16898 |> Jsont.Object.mem "albumName" Jsont.string ~enc:(fun r -> r.album_name)
16899 |> Jsont.Object.mem "albumThumbnailAssetId" Openapi.Runtime.nullable_string
16900 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.album_thumbnail_asset_id)
16901 |> Jsont.Object.mem "albumUsers" (Jsont.list AlbumUser.ResponseDto.jsont) ~enc:(fun r -> r.album_users)
16902 |> Jsont.Object.mem "assetCount" Jsont.int ~enc:(fun r -> r.asset_count)
16903 |> Jsont.Object.mem "assets" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.assets)
16904 |> Jsont.Object.opt_mem "contributorCounts" (Jsont.list ContributorCount.ResponseDto.jsont) ~enc:(fun r -> r.contributor_counts)
16905 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
16906 |> Jsont.Object.mem "description" Jsont.string ~enc:(fun r -> r.description)
16907 |> Jsont.Object.opt_mem "endDate" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.end_date)
16908 |> Jsont.Object.mem "hasSharedLink" Jsont.bool ~enc:(fun r -> r.has_shared_link)
16909 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
16910 |> Jsont.Object.mem "isActivityEnabled" Jsont.bool ~enc:(fun r -> r.is_activity_enabled)
16911 |> Jsont.Object.opt_mem "lastModifiedAssetTimestamp" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.last_modified_asset_timestamp)
16912 |> Jsont.Object.opt_mem "order" AssetOrder.T.jsont ~enc:(fun r -> r.order)
16913 |> Jsont.Object.mem "owner" User.ResponseDto.jsont ~enc:(fun r -> r.owner)
16914 |> Jsont.Object.mem "ownerId" Jsont.string ~enc:(fun r -> r.owner_id)
16915 |> Jsont.Object.mem "shared" Jsont.bool ~enc:(fun r -> r.shared)
16916 |> Jsont.Object.opt_mem "startDate" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.start_date)
16917 |> Jsont.Object.mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
16918 |> Jsont.Object.skip_unknown
16919 |> Jsont.Object.finish
16920 end
16921
16922 (** List all albums
16923
16924 Retrieve a list of albums available to the authenticated user.
16925 @param asset_id Only returns albums that contain the asset
16926 Ignores the shared parameter
16927 undefined: get all albums
16928 *)
16929 let get_all_albums ?asset_id ?shared client () =
16930 let op_name = "get_all_albums" in
16931 let url_path = "/albums" in
16932 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"assetId" ~value:asset_id; Openapi.Runtime.Query.optional ~key:"shared" ~value:shared]) in
16933 let url = client.base_url ^ url_path ^ query in
16934 let response =
16935 try Requests.get client.session url
16936 with Eio.Io _ as ex ->
16937 let bt = Printexc.get_raw_backtrace () in
16938 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
16939 in
16940 if Requests.Response.ok response then
16941 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
16942 else
16943 let body = Requests.Response.text response in
16944 let parsed_body =
16945 match Jsont_bytesrw.decode_string Jsont.json body with
16946 | Ok json -> Some (Openapi.Runtime.Json json)
16947 | Error _ -> Some (Openapi.Runtime.Raw body)
16948 in
16949 raise (Openapi.Runtime.Api_error {
16950 operation = op_name;
16951 method_ = "GET";
16952 url;
16953 status = Requests.Response.status_code response;
16954 body;
16955 parsed_body;
16956 })
16957
16958 (** Create an album
16959
16960 Create a new album. The album can also be created with initial users and assets. *)
16961 let create_album ~body client () =
16962 let op_name = "create_album" in
16963 let url_path = "/albums" in
16964 let query = "" in
16965 let url = client.base_url ^ url_path ^ query in
16966 let response =
16967 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateAlbum.Dto.jsont body)) url
16968 with Eio.Io _ as ex ->
16969 let bt = Printexc.get_raw_backtrace () in
16970 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
16971 in
16972 if Requests.Response.ok response then
16973 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
16974 else
16975 let body = Requests.Response.text response in
16976 let parsed_body =
16977 match Jsont_bytesrw.decode_string Jsont.json body with
16978 | Ok json -> Some (Openapi.Runtime.Json json)
16979 | Error _ -> Some (Openapi.Runtime.Raw body)
16980 in
16981 raise (Openapi.Runtime.Api_error {
16982 operation = op_name;
16983 method_ = "POST";
16984 url;
16985 status = Requests.Response.status_code response;
16986 body;
16987 parsed_body;
16988 })
16989
16990 (** Retrieve an album
16991
16992 Retrieve information about a specific album by its ID. *)
16993 let get_album_info ~id ?key ?slug ?without_assets client () =
16994 let op_name = "get_album_info" in
16995 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}" in
16996 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug; Openapi.Runtime.Query.optional ~key:"withoutAssets" ~value:without_assets]) in
16997 let url = client.base_url ^ url_path ^ query in
16998 let response =
16999 try Requests.get client.session url
17000 with Eio.Io _ as ex ->
17001 let bt = Printexc.get_raw_backtrace () in
17002 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17003 in
17004 if Requests.Response.ok response then
17005 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17006 else
17007 let body = Requests.Response.text response in
17008 let parsed_body =
17009 match Jsont_bytesrw.decode_string Jsont.json body with
17010 | Ok json -> Some (Openapi.Runtime.Json json)
17011 | Error _ -> Some (Openapi.Runtime.Raw body)
17012 in
17013 raise (Openapi.Runtime.Api_error {
17014 operation = op_name;
17015 method_ = "GET";
17016 url;
17017 status = Requests.Response.status_code response;
17018 body;
17019 parsed_body;
17020 })
17021
17022 (** Update an album
17023
17024 Update the information of a specific album by its ID. This endpoint can be used to update the album name, description, sort order, etc. However, it is not used to add or remove assets or users from the album. *)
17025 let update_album_info ~id ~body client () =
17026 let op_name = "update_album_info" in
17027 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}" in
17028 let query = "" in
17029 let url = client.base_url ^ url_path ^ query in
17030 let response =
17031 try Requests.patch client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateAlbum.Dto.jsont body)) url
17032 with Eio.Io _ as ex ->
17033 let bt = Printexc.get_raw_backtrace () in
17034 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PATCH" url
17035 in
17036 if Requests.Response.ok response then
17037 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17038 else
17039 let body = Requests.Response.text response in
17040 let parsed_body =
17041 match Jsont_bytesrw.decode_string Jsont.json body with
17042 | Ok json -> Some (Openapi.Runtime.Json json)
17043 | Error _ -> Some (Openapi.Runtime.Raw body)
17044 in
17045 raise (Openapi.Runtime.Api_error {
17046 operation = op_name;
17047 method_ = "PATCH";
17048 url;
17049 status = Requests.Response.status_code response;
17050 body;
17051 parsed_body;
17052 })
17053
17054 (** Share album with users
17055
17056 Share an album with multiple users. Each user can be given a specific role in the album. *)
17057 let add_users_to_album ~id ~body client () =
17058 let op_name = "add_users_to_album" in
17059 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}/users" in
17060 let query = "" in
17061 let url = client.base_url ^ url_path ^ query in
17062 let response =
17063 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AddUsers.Dto.jsont body)) url
17064 with Eio.Io _ as ex ->
17065 let bt = Printexc.get_raw_backtrace () in
17066 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
17067 in
17068 if Requests.Response.ok response then
17069 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17070 else
17071 let body = Requests.Response.text response in
17072 let parsed_body =
17073 match Jsont_bytesrw.decode_string Jsont.json body with
17074 | Ok json -> Some (Openapi.Runtime.Json json)
17075 | Error _ -> Some (Openapi.Runtime.Raw body)
17076 in
17077 raise (Openapi.Runtime.Api_error {
17078 operation = op_name;
17079 method_ = "PUT";
17080 url;
17081 status = Requests.Response.status_code response;
17082 body;
17083 parsed_body;
17084 })
17085end
17086
17087module SharedLink = struct
17088 module Types = struct
17089 module Type = struct
17090 type t = [
17091 | `Album
17092 | `Individual
17093 ]
17094 end
17095
17096 module ResponseDto = struct
17097 type t = {
17098 album : Album.ResponseDto.t option;
17099 allow_download : bool;
17100 allow_upload : bool;
17101 assets : Asset.ResponseDto.t list;
17102 created_at : Ptime.t;
17103 description : string option;
17104 expires_at : Ptime.t option;
17105 id : string;
17106 key : string;
17107 password : string option;
17108 show_metadata : bool;
17109 slug : string option;
17110 token : string option;
17111 type_ : Type.t;
17112 user_id : string;
17113 }
17114 end
17115
17116 module CreateDto = struct
17117 type t = {
17118 album_id : string option;
17119 allow_download : bool;
17120 allow_upload : bool option;
17121 asset_ids : string list option;
17122 description : string option;
17123 expires_at : Ptime.t option;
17124 password : string option;
17125 show_metadata : bool;
17126 slug : string option;
17127 type_ : Type.t;
17128 }
17129 end
17130 end
17131
17132 module Type = struct
17133 include Types.Type
17134
17135 let jsont : t Jsont.t =
17136 Jsont.map Jsont.string ~kind:"SharedLinkType"
17137 ~dec:(function
17138 | "ALBUM" -> `Album
17139 | "INDIVIDUAL" -> `Individual
17140 | s -> Jsont.Error.msgf Jsont.Meta.none "Unknown value: %s" s)
17141 ~enc:(function
17142 | `Album -> "ALBUM"
17143 | `Individual -> "INDIVIDUAL")
17144 end
17145
17146 module ResponseDto = struct
17147 include Types.ResponseDto
17148
17149 let v ~allow_download ~allow_upload ~assets ~created_at ~id ~key ~show_metadata ~type_ ~user_id ?album ?description ?expires_at ?password ?slug ?token () = { album; allow_download; allow_upload; assets; created_at; description; expires_at; id; key; password; show_metadata; slug; token; type_; user_id }
17150
17151 let album t = t.album
17152 let allow_download t = t.allow_download
17153 let allow_upload t = t.allow_upload
17154 let assets t = t.assets
17155 let created_at t = t.created_at
17156 let description t = t.description
17157 let expires_at t = t.expires_at
17158 let id t = t.id
17159 let key t = t.key
17160 let password t = t.password
17161 let show_metadata t = t.show_metadata
17162 let slug t = t.slug
17163 let token t = t.token
17164 let type_ t = t.type_
17165 let user_id t = t.user_id
17166
17167 let jsont : t Jsont.t =
17168 Jsont.Object.map ~kind:"SharedLinkResponseDto"
17169 (fun album allow_download allow_upload assets created_at description expires_at id key password show_metadata slug token type_ user_id -> { album; allow_download; allow_upload; assets; created_at; description; expires_at; id; key; password; show_metadata; slug; token; type_; user_id })
17170 |> Jsont.Object.opt_mem "album" Album.ResponseDto.jsont ~enc:(fun r -> r.album)
17171 |> Jsont.Object.mem "allowDownload" Jsont.bool ~enc:(fun r -> r.allow_download)
17172 |> Jsont.Object.mem "allowUpload" Jsont.bool ~enc:(fun r -> r.allow_upload)
17173 |> Jsont.Object.mem "assets" (Jsont.list Asset.ResponseDto.jsont) ~enc:(fun r -> r.assets)
17174 |> Jsont.Object.mem "createdAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.created_at)
17175 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
17176 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
17177 |> Jsont.Object.mem "expiresAt" Openapi.Runtime.nullable_ptime
17178 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.expires_at)
17179 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
17180 |> Jsont.Object.mem "key" Jsont.string ~enc:(fun r -> r.key)
17181 |> Jsont.Object.mem "password" Openapi.Runtime.nullable_string
17182 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.password)
17183 |> Jsont.Object.mem "showMetadata" Jsont.bool ~enc:(fun r -> r.show_metadata)
17184 |> Jsont.Object.mem "slug" Openapi.Runtime.nullable_string
17185 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.slug)
17186 |> Jsont.Object.mem "token" Openapi.Runtime.nullable_string
17187 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.token)
17188 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
17189 |> Jsont.Object.mem "userId" Jsont.string ~enc:(fun r -> r.user_id)
17190 |> Jsont.Object.skip_unknown
17191 |> Jsont.Object.finish
17192 end
17193
17194 module CreateDto = struct
17195 include Types.CreateDto
17196
17197 let v ~type_ ?(allow_download=true) ?(expires_at=None) ?(show_metadata=true) ?album_id ?allow_upload ?asset_ids ?description ?password ?slug () = { album_id; allow_download; allow_upload; asset_ids; description; expires_at; password; show_metadata; slug; type_ }
17198
17199 let album_id t = t.album_id
17200 let allow_download t = t.allow_download
17201 let allow_upload t = t.allow_upload
17202 let asset_ids t = t.asset_ids
17203 let description t = t.description
17204 let expires_at t = t.expires_at
17205 let password t = t.password
17206 let show_metadata t = t.show_metadata
17207 let slug t = t.slug
17208 let type_ t = t.type_
17209
17210 let jsont : t Jsont.t =
17211 Jsont.Object.map ~kind:"SharedLinkCreateDto"
17212 (fun album_id allow_download allow_upload asset_ids description expires_at password show_metadata slug type_ -> { album_id; allow_download; allow_upload; asset_ids; description; expires_at; password; show_metadata; slug; type_ })
17213 |> Jsont.Object.opt_mem "albumId" Jsont.string ~enc:(fun r -> r.album_id)
17214 |> Jsont.Object.mem "allowDownload" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.allow_download)
17215 |> Jsont.Object.opt_mem "allowUpload" Jsont.bool ~enc:(fun r -> r.allow_upload)
17216 |> Jsont.Object.opt_mem "assetIds" (Jsont.list Jsont.string) ~enc:(fun r -> r.asset_ids)
17217 |> Jsont.Object.mem "description" Openapi.Runtime.nullable_string
17218 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.description)
17219 |> Jsont.Object.mem "expiresAt" Openapi.Runtime.nullable_ptime
17220 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.expires_at)
17221 |> Jsont.Object.mem "password" Openapi.Runtime.nullable_string
17222 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.password)
17223 |> Jsont.Object.mem "showMetadata" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.show_metadata)
17224 |> Jsont.Object.mem "slug" Openapi.Runtime.nullable_string
17225 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.slug)
17226 |> Jsont.Object.mem "type" Type.jsont ~enc:(fun r -> r.type_)
17227 |> Jsont.Object.skip_unknown
17228 |> Jsont.Object.finish
17229 end
17230
17231 (** Retrieve all shared links
17232
17233 Retrieve a list of all shared links. *)
17234 let get_all_shared_links ?album_id ?id client () =
17235 let op_name = "get_all_shared_links" in
17236 let url_path = "/shared-links" in
17237 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"albumId" ~value:album_id; Openapi.Runtime.Query.optional ~key:"id" ~value:id]) in
17238 let url = client.base_url ^ url_path ^ query in
17239 let response =
17240 try Requests.get client.session url
17241 with Eio.Io _ as ex ->
17242 let bt = Printexc.get_raw_backtrace () in
17243 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17244 in
17245 if Requests.Response.ok response then
17246 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17247 else
17248 let body = Requests.Response.text response in
17249 let parsed_body =
17250 match Jsont_bytesrw.decode_string Jsont.json body with
17251 | Ok json -> Some (Openapi.Runtime.Json json)
17252 | Error _ -> Some (Openapi.Runtime.Raw body)
17253 in
17254 raise (Openapi.Runtime.Api_error {
17255 operation = op_name;
17256 method_ = "GET";
17257 url;
17258 status = Requests.Response.status_code response;
17259 body;
17260 parsed_body;
17261 })
17262
17263 (** Create a shared link
17264
17265 Create a new shared link. *)
17266 let create_shared_link ~body client () =
17267 let op_name = "create_shared_link" in
17268 let url_path = "/shared-links" in
17269 let query = "" in
17270 let url = client.base_url ^ url_path ^ query in
17271 let response =
17272 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
17273 with Eio.Io _ as ex ->
17274 let bt = Printexc.get_raw_backtrace () in
17275 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
17276 in
17277 if Requests.Response.ok response then
17278 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17279 else
17280 let body = Requests.Response.text response in
17281 let parsed_body =
17282 match Jsont_bytesrw.decode_string Jsont.json body with
17283 | Ok json -> Some (Openapi.Runtime.Json json)
17284 | Error _ -> Some (Openapi.Runtime.Raw body)
17285 in
17286 raise (Openapi.Runtime.Api_error {
17287 operation = op_name;
17288 method_ = "POST";
17289 url;
17290 status = Requests.Response.status_code response;
17291 body;
17292 parsed_body;
17293 })
17294
17295 (** Retrieve current shared link
17296
17297 Retrieve the current shared link associated with authentication method. *)
17298 let get_my_shared_link ?key ?password ?slug ?token client () =
17299 let op_name = "get_my_shared_link" in
17300 let url_path = "/shared-links/me" in
17301 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"password" ~value:password; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug; Openapi.Runtime.Query.optional ~key:"token" ~value:token]) in
17302 let url = client.base_url ^ url_path ^ query in
17303 let response =
17304 try Requests.get client.session url
17305 with Eio.Io _ as ex ->
17306 let bt = Printexc.get_raw_backtrace () in
17307 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17308 in
17309 if Requests.Response.ok response then
17310 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17311 else
17312 let body = Requests.Response.text response in
17313 let parsed_body =
17314 match Jsont_bytesrw.decode_string Jsont.json body with
17315 | Ok json -> Some (Openapi.Runtime.Json json)
17316 | Error _ -> Some (Openapi.Runtime.Raw body)
17317 in
17318 raise (Openapi.Runtime.Api_error {
17319 operation = op_name;
17320 method_ = "GET";
17321 url;
17322 status = Requests.Response.status_code response;
17323 body;
17324 parsed_body;
17325 })
17326
17327 (** Retrieve a shared link
17328
17329 Retrieve a specific shared link by its ID. *)
17330 let get_shared_link_by_id ~id client () =
17331 let op_name = "get_shared_link_by_id" in
17332 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/shared-links/{id}" in
17333 let query = "" in
17334 let url = client.base_url ^ url_path ^ query in
17335 let response =
17336 try Requests.get client.session url
17337 with Eio.Io _ as ex ->
17338 let bt = Printexc.get_raw_backtrace () in
17339 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17340 in
17341 if Requests.Response.ok response then
17342 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17343 else
17344 let body = Requests.Response.text response in
17345 let parsed_body =
17346 match Jsont_bytesrw.decode_string Jsont.json body with
17347 | Ok json -> Some (Openapi.Runtime.Json json)
17348 | Error _ -> Some (Openapi.Runtime.Raw body)
17349 in
17350 raise (Openapi.Runtime.Api_error {
17351 operation = op_name;
17352 method_ = "GET";
17353 url;
17354 status = Requests.Response.status_code response;
17355 body;
17356 parsed_body;
17357 })
17358
17359 (** Update a shared link
17360
17361 Update an existing shared link by its ID. *)
17362 let update_shared_link ~id ~body client () =
17363 let op_name = "update_shared_link" in
17364 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/shared-links/{id}" in
17365 let query = "" in
17366 let url = client.base_url ^ url_path ^ query in
17367 let response =
17368 try Requests.patch client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SharedLinkEdit.Dto.jsont body)) url
17369 with Eio.Io _ as ex ->
17370 let bt = Printexc.get_raw_backtrace () in
17371 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PATCH" url
17372 in
17373 if Requests.Response.ok response then
17374 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17375 else
17376 let body = Requests.Response.text response in
17377 let parsed_body =
17378 match Jsont_bytesrw.decode_string Jsont.json body with
17379 | Ok json -> Some (Openapi.Runtime.Json json)
17380 | Error _ -> Some (Openapi.Runtime.Raw body)
17381 in
17382 raise (Openapi.Runtime.Api_error {
17383 operation = op_name;
17384 method_ = "PATCH";
17385 url;
17386 status = Requests.Response.status_code response;
17387 body;
17388 parsed_body;
17389 })
17390end
17391
17392module SearchAlbum = struct
17393 module Types = struct
17394 module ResponseDto = struct
17395 type t = {
17396 count : int;
17397 facets : SearchFacet.ResponseDto.t list;
17398 items : Album.ResponseDto.t list;
17399 total : int;
17400 }
17401 end
17402 end
17403
17404 module ResponseDto = struct
17405 include Types.ResponseDto
17406
17407 let v ~count ~facets ~items ~total () = { count; facets; items; total }
17408
17409 let count t = t.count
17410 let facets t = t.facets
17411 let items t = t.items
17412 let total t = t.total
17413
17414 let jsont : t Jsont.t =
17415 Jsont.Object.map ~kind:"SearchAlbumResponseDto"
17416 (fun count facets items total -> { count; facets; items; total })
17417 |> Jsont.Object.mem "count" Jsont.int ~enc:(fun r -> r.count)
17418 |> Jsont.Object.mem "facets" (Jsont.list SearchFacet.ResponseDto.jsont) ~enc:(fun r -> r.facets)
17419 |> Jsont.Object.mem "items" (Jsont.list Album.ResponseDto.jsont) ~enc:(fun r -> r.items)
17420 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
17421 |> Jsont.Object.skip_unknown
17422 |> Jsont.Object.finish
17423 end
17424end
17425
17426module Search = struct
17427 module Types = struct
17428 module ResponseDto = struct
17429 type t = {
17430 albums : SearchAlbum.ResponseDto.t;
17431 assets : SearchAsset.ResponseDto.t;
17432 }
17433 end
17434 end
17435
17436 module ResponseDto = struct
17437 include Types.ResponseDto
17438
17439 let v ~albums ~assets () = { albums; assets }
17440
17441 let albums t = t.albums
17442 let assets t = t.assets
17443
17444 let jsont : t Jsont.t =
17445 Jsont.Object.map ~kind:"SearchResponseDto"
17446 (fun albums assets -> { albums; assets })
17447 |> Jsont.Object.mem "albums" SearchAlbum.ResponseDto.jsont ~enc:(fun r -> r.albums)
17448 |> Jsont.Object.mem "assets" SearchAsset.ResponseDto.jsont ~enc:(fun r -> r.assets)
17449 |> Jsont.Object.skip_unknown
17450 |> Jsont.Object.finish
17451 end
17452
17453 (** Search assets by metadata
17454
17455 Search for assets based on various metadata criteria. *)
17456 let search_assets ~body client () =
17457 let op_name = "search_assets" in
17458 let url_path = "/search/metadata" in
17459 let query = "" in
17460 let url = client.base_url ^ url_path ^ query in
17461 let response =
17462 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json MetadataSearch.Dto.jsont body)) url
17463 with Eio.Io _ as ex ->
17464 let bt = Printexc.get_raw_backtrace () in
17465 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
17466 in
17467 if Requests.Response.ok response then
17468 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17469 else
17470 let body = Requests.Response.text response in
17471 let parsed_body =
17472 match Jsont_bytesrw.decode_string Jsont.json body with
17473 | Ok json -> Some (Openapi.Runtime.Json json)
17474 | Error _ -> Some (Openapi.Runtime.Raw body)
17475 in
17476 raise (Openapi.Runtime.Api_error {
17477 operation = op_name;
17478 method_ = "POST";
17479 url;
17480 status = Requests.Response.status_code response;
17481 body;
17482 parsed_body;
17483 })
17484
17485 (** Smart asset search
17486
17487 Perform a smart search for assets by using machine learning vectors to determine relevance. *)
17488 let search_smart ~body client () =
17489 let op_name = "search_smart" in
17490 let url_path = "/search/smart" in
17491 let query = "" in
17492 let url = client.base_url ^ url_path ^ query in
17493 let response =
17494 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SmartSearch.Dto.jsont body)) url
17495 with Eio.Io _ as ex ->
17496 let bt = Printexc.get_raw_backtrace () in
17497 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
17498 in
17499 if Requests.Response.ok response then
17500 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17501 else
17502 let body = Requests.Response.text response in
17503 let parsed_body =
17504 match Jsont_bytesrw.decode_string Jsont.json body with
17505 | Ok json -> Some (Openapi.Runtime.Json json)
17506 | Error _ -> Some (Openapi.Runtime.Raw body)
17507 in
17508 raise (Openapi.Runtime.Api_error {
17509 operation = op_name;
17510 method_ = "POST";
17511 url;
17512 status = Requests.Response.status_code response;
17513 body;
17514 parsed_body;
17515 })
17516end
17517
17518module AlbumStatistics = struct
17519 module Types = struct
17520 module ResponseDto = struct
17521 type t = {
17522 not_shared : int;
17523 owned : int;
17524 shared : int;
17525 }
17526 end
17527 end
17528
17529 module ResponseDto = struct
17530 include Types.ResponseDto
17531
17532 let v ~not_shared ~owned ~shared () = { not_shared; owned; shared }
17533
17534 let not_shared t = t.not_shared
17535 let owned t = t.owned
17536 let shared t = t.shared
17537
17538 let jsont : t Jsont.t =
17539 Jsont.Object.map ~kind:"AlbumStatisticsResponseDto"
17540 (fun not_shared owned shared -> { not_shared; owned; shared })
17541 |> Jsont.Object.mem "notShared" Jsont.int ~enc:(fun r -> r.not_shared)
17542 |> Jsont.Object.mem "owned" Jsont.int ~enc:(fun r -> r.owned)
17543 |> Jsont.Object.mem "shared" Jsont.int ~enc:(fun r -> r.shared)
17544 |> Jsont.Object.skip_unknown
17545 |> Jsont.Object.finish
17546 end
17547
17548 (** Retrieve album statistics
17549
17550 Returns statistics about the albums available to the authenticated user. *)
17551 let get_album_statistics client () =
17552 let op_name = "get_album_statistics" in
17553 let url_path = "/albums/statistics" in
17554 let query = "" in
17555 let url = client.base_url ^ url_path ^ query in
17556 let response =
17557 try Requests.get client.session url
17558 with Eio.Io _ as ex ->
17559 let bt = Printexc.get_raw_backtrace () in
17560 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17561 in
17562 if Requests.Response.ok response then
17563 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17564 else
17565 let body = Requests.Response.text response in
17566 let parsed_body =
17567 match Jsont_bytesrw.decode_string Jsont.json body with
17568 | Ok json -> Some (Openapi.Runtime.Json json)
17569 | Error _ -> Some (Openapi.Runtime.Raw body)
17570 in
17571 raise (Openapi.Runtime.Api_error {
17572 operation = op_name;
17573 method_ = "GET";
17574 url;
17575 status = Requests.Response.status_code response;
17576 body;
17577 parsed_body;
17578 })
17579end
17580
17581module AdminOnboarding = struct
17582 module Types = struct
17583 module UpdateDto = struct
17584 type t = {
17585 is_onboarded : bool;
17586 }
17587 end
17588 end
17589
17590 module UpdateDto = struct
17591 include Types.UpdateDto
17592
17593 let v ~is_onboarded () = { is_onboarded }
17594
17595 let is_onboarded t = t.is_onboarded
17596
17597 let jsont : t Jsont.t =
17598 Jsont.Object.map ~kind:"AdminOnboardingUpdateDto"
17599 (fun is_onboarded -> { is_onboarded })
17600 |> Jsont.Object.mem "isOnboarded" Jsont.bool ~enc:(fun r -> r.is_onboarded)
17601 |> Jsont.Object.skip_unknown
17602 |> Jsont.Object.finish
17603 end
17604
17605 (** Retrieve admin onboarding
17606
17607 Retrieve the current admin onboarding status. *)
17608 let get_admin_onboarding client () =
17609 let op_name = "get_admin_onboarding" in
17610 let url_path = "/system-metadata/admin-onboarding" in
17611 let query = "" in
17612 let url = client.base_url ^ url_path ^ query in
17613 let response =
17614 try Requests.get client.session url
17615 with Eio.Io _ as ex ->
17616 let bt = Printexc.get_raw_backtrace () in
17617 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17618 in
17619 if Requests.Response.ok response then
17620 Openapi.Runtime.Json.decode_json_exn UpdateDto.jsont (Requests.Response.json response)
17621 else
17622 let body = Requests.Response.text response in
17623 let parsed_body =
17624 match Jsont_bytesrw.decode_string Jsont.json body with
17625 | Ok json -> Some (Openapi.Runtime.Json json)
17626 | Error _ -> Some (Openapi.Runtime.Raw body)
17627 in
17628 raise (Openapi.Runtime.Api_error {
17629 operation = op_name;
17630 method_ = "GET";
17631 url;
17632 status = Requests.Response.status_code response;
17633 body;
17634 parsed_body;
17635 })
17636end
17637
17638module ActivityStatistics = struct
17639 module Types = struct
17640 module ResponseDto = struct
17641 type t = {
17642 comments : int;
17643 likes : int;
17644 }
17645 end
17646 end
17647
17648 module ResponseDto = struct
17649 include Types.ResponseDto
17650
17651 let v ~comments ~likes () = { comments; likes }
17652
17653 let comments t = t.comments
17654 let likes t = t.likes
17655
17656 let jsont : t Jsont.t =
17657 Jsont.Object.map ~kind:"ActivityStatisticsResponseDto"
17658 (fun comments likes -> { comments; likes })
17659 |> Jsont.Object.mem "comments" Jsont.int ~enc:(fun r -> r.comments)
17660 |> Jsont.Object.mem "likes" Jsont.int ~enc:(fun r -> r.likes)
17661 |> Jsont.Object.skip_unknown
17662 |> Jsont.Object.finish
17663 end
17664
17665 (** Retrieve activity statistics
17666
17667 Returns the number of likes and comments for a given album or asset in an album. *)
17668 let get_activity_statistics ~album_id ?asset_id client () =
17669 let op_name = "get_activity_statistics" in
17670 let url_path = "/activities/statistics" in
17671 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"albumId" ~value:album_id; Openapi.Runtime.Query.optional ~key:"assetId" ~value:asset_id]) in
17672 let url = client.base_url ^ url_path ^ query in
17673 let response =
17674 try Requests.get client.session url
17675 with Eio.Io _ as ex ->
17676 let bt = Printexc.get_raw_backtrace () in
17677 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17678 in
17679 if Requests.Response.ok response then
17680 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17681 else
17682 let body = Requests.Response.text response in
17683 let parsed_body =
17684 match Jsont_bytesrw.decode_string Jsont.json body with
17685 | Ok json -> Some (Openapi.Runtime.Json json)
17686 | Error _ -> Some (Openapi.Runtime.Raw body)
17687 in
17688 raise (Openapi.Runtime.Api_error {
17689 operation = op_name;
17690 method_ = "GET";
17691 url;
17692 status = Requests.Response.status_code response;
17693 body;
17694 parsed_body;
17695 })
17696end
17697
17698module UserPreferences = struct
17699 module Types = struct
17700 module UpdateDto = struct
17701 type t = {
17702 albums : Albums.Update.t option;
17703 avatar : Avatar.Update.t option;
17704 cast : Cast.Update.t option;
17705 download : Download.Update.t option;
17706 email_notifications : EmailNotifications.Update.t option;
17707 folders : Folders.Update.t option;
17708 memories : Memories.Update.t option;
17709 people : Jsont.json option;
17710 purchase : Purchase.Update.t option;
17711 ratings : Ratings.Update.t option;
17712 shared_links : SharedLinks.Update.t option;
17713 tags : Tags.Update.t option;
17714 }
17715 end
17716
17717 module ResponseDto = struct
17718 type t = {
17719 albums : Albums.Response.t;
17720 cast : Cast.Response.t;
17721 download : Download.Response.t;
17722 email_notifications : EmailNotifications.Response.t;
17723 folders : Folders.Response.t;
17724 memories : Memories.Response.t;
17725 people : Jsont.json;
17726 purchase : Purchase.Response.t;
17727 ratings : Ratings.Response.t;
17728 shared_links : SharedLinks.Response.t;
17729 tags : Tags.Response.t;
17730 }
17731 end
17732 end
17733
17734 module UpdateDto = struct
17735 include Types.UpdateDto
17736
17737 let v ?albums ?avatar ?cast ?download ?email_notifications ?folders ?memories ?people ?purchase ?ratings ?shared_links ?tags () = { albums; avatar; cast; download; email_notifications; folders; memories; people; purchase; ratings; shared_links; tags }
17738
17739 let albums t = t.albums
17740 let avatar t = t.avatar
17741 let cast t = t.cast
17742 let download t = t.download
17743 let email_notifications t = t.email_notifications
17744 let folders t = t.folders
17745 let memories t = t.memories
17746 let people t = t.people
17747 let purchase t = t.purchase
17748 let ratings t = t.ratings
17749 let shared_links t = t.shared_links
17750 let tags t = t.tags
17751
17752 let jsont : t Jsont.t =
17753 Jsont.Object.map ~kind:"UserPreferencesUpdateDto"
17754 (fun albums avatar cast download email_notifications folders memories people purchase ratings shared_links tags -> { albums; avatar; cast; download; email_notifications; folders; memories; people; purchase; ratings; shared_links; tags })
17755 |> Jsont.Object.opt_mem "albums" Albums.Update.jsont ~enc:(fun r -> r.albums)
17756 |> Jsont.Object.opt_mem "avatar" Avatar.Update.jsont ~enc:(fun r -> r.avatar)
17757 |> Jsont.Object.opt_mem "cast" Cast.Update.jsont ~enc:(fun r -> r.cast)
17758 |> Jsont.Object.opt_mem "download" Download.Update.jsont ~enc:(fun r -> r.download)
17759 |> Jsont.Object.opt_mem "emailNotifications" EmailNotifications.Update.jsont ~enc:(fun r -> r.email_notifications)
17760 |> Jsont.Object.opt_mem "folders" Folders.Update.jsont ~enc:(fun r -> r.folders)
17761 |> Jsont.Object.opt_mem "memories" Memories.Update.jsont ~enc:(fun r -> r.memories)
17762 |> Jsont.Object.opt_mem "people" Jsont.json ~enc:(fun r -> r.people)
17763 |> Jsont.Object.opt_mem "purchase" Purchase.Update.jsont ~enc:(fun r -> r.purchase)
17764 |> Jsont.Object.opt_mem "ratings" Ratings.Update.jsont ~enc:(fun r -> r.ratings)
17765 |> Jsont.Object.opt_mem "sharedLinks" SharedLinks.Update.jsont ~enc:(fun r -> r.shared_links)
17766 |> Jsont.Object.opt_mem "tags" Tags.Update.jsont ~enc:(fun r -> r.tags)
17767 |> Jsont.Object.skip_unknown
17768 |> Jsont.Object.finish
17769 end
17770
17771 module ResponseDto = struct
17772 include Types.ResponseDto
17773
17774 let v ~albums ~cast ~download ~email_notifications ~folders ~memories ~people ~purchase ~ratings ~shared_links ~tags () = { albums; cast; download; email_notifications; folders; memories; people; purchase; ratings; shared_links; tags }
17775
17776 let albums t = t.albums
17777 let cast t = t.cast
17778 let download t = t.download
17779 let email_notifications t = t.email_notifications
17780 let folders t = t.folders
17781 let memories t = t.memories
17782 let people t = t.people
17783 let purchase t = t.purchase
17784 let ratings t = t.ratings
17785 let shared_links t = t.shared_links
17786 let tags t = t.tags
17787
17788 let jsont : t Jsont.t =
17789 Jsont.Object.map ~kind:"UserPreferencesResponseDto"
17790 (fun albums cast download email_notifications folders memories people purchase ratings shared_links tags -> { albums; cast; download; email_notifications; folders; memories; people; purchase; ratings; shared_links; tags })
17791 |> Jsont.Object.mem "albums" Albums.Response.jsont ~enc:(fun r -> r.albums)
17792 |> Jsont.Object.mem "cast" Cast.Response.jsont ~enc:(fun r -> r.cast)
17793 |> Jsont.Object.mem "download" Download.Response.jsont ~enc:(fun r -> r.download)
17794 |> Jsont.Object.mem "emailNotifications" EmailNotifications.Response.jsont ~enc:(fun r -> r.email_notifications)
17795 |> Jsont.Object.mem "folders" Folders.Response.jsont ~enc:(fun r -> r.folders)
17796 |> Jsont.Object.mem "memories" Memories.Response.jsont ~enc:(fun r -> r.memories)
17797 |> Jsont.Object.mem "people" Jsont.json ~enc:(fun r -> r.people)
17798 |> Jsont.Object.mem "purchase" Purchase.Response.jsont ~enc:(fun r -> r.purchase)
17799 |> Jsont.Object.mem "ratings" Ratings.Response.jsont ~enc:(fun r -> r.ratings)
17800 |> Jsont.Object.mem "sharedLinks" SharedLinks.Response.jsont ~enc:(fun r -> r.shared_links)
17801 |> Jsont.Object.mem "tags" Tags.Response.jsont ~enc:(fun r -> r.tags)
17802 |> Jsont.Object.skip_unknown
17803 |> Jsont.Object.finish
17804 end
17805
17806 (** Retrieve user preferences
17807
17808 Retrieve the preferences of a specific user. *)
17809 let get_user_preferences_admin ~id client () =
17810 let op_name = "get_user_preferences_admin" in
17811 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}/preferences" in
17812 let query = "" in
17813 let url = client.base_url ^ url_path ^ query in
17814 let response =
17815 try Requests.get client.session url
17816 with Eio.Io _ as ex ->
17817 let bt = Printexc.get_raw_backtrace () in
17818 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17819 in
17820 if Requests.Response.ok response then
17821 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17822 else
17823 let body = Requests.Response.text response in
17824 let parsed_body =
17825 match Jsont_bytesrw.decode_string Jsont.json body with
17826 | Ok json -> Some (Openapi.Runtime.Json json)
17827 | Error _ -> Some (Openapi.Runtime.Raw body)
17828 in
17829 raise (Openapi.Runtime.Api_error {
17830 operation = op_name;
17831 method_ = "GET";
17832 url;
17833 status = Requests.Response.status_code response;
17834 body;
17835 parsed_body;
17836 })
17837
17838 (** Update user preferences
17839
17840 Update the preferences of a specific user. *)
17841 let update_user_preferences_admin ~id ~body client () =
17842 let op_name = "update_user_preferences_admin" in
17843 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/admin/users/{id}/preferences" in
17844 let query = "" in
17845 let url = client.base_url ^ url_path ^ query in
17846 let response =
17847 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
17848 with Eio.Io _ as ex ->
17849 let bt = Printexc.get_raw_backtrace () in
17850 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
17851 in
17852 if Requests.Response.ok response then
17853 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17854 else
17855 let body = Requests.Response.text response in
17856 let parsed_body =
17857 match Jsont_bytesrw.decode_string Jsont.json body with
17858 | Ok json -> Some (Openapi.Runtime.Json json)
17859 | Error _ -> Some (Openapi.Runtime.Raw body)
17860 in
17861 raise (Openapi.Runtime.Api_error {
17862 operation = op_name;
17863 method_ = "PUT";
17864 url;
17865 status = Requests.Response.status_code response;
17866 body;
17867 parsed_body;
17868 })
17869
17870 (** Get my preferences
17871
17872 Retrieve the preferences for the current user. *)
17873 let get_my_preferences client () =
17874 let op_name = "get_my_preferences" in
17875 let url_path = "/users/me/preferences" in
17876 let query = "" in
17877 let url = client.base_url ^ url_path ^ query in
17878 let response =
17879 try Requests.get client.session url
17880 with Eio.Io _ as ex ->
17881 let bt = Printexc.get_raw_backtrace () in
17882 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
17883 in
17884 if Requests.Response.ok response then
17885 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17886 else
17887 let body = Requests.Response.text response in
17888 let parsed_body =
17889 match Jsont_bytesrw.decode_string Jsont.json body with
17890 | Ok json -> Some (Openapi.Runtime.Json json)
17891 | Error _ -> Some (Openapi.Runtime.Raw body)
17892 in
17893 raise (Openapi.Runtime.Api_error {
17894 operation = op_name;
17895 method_ = "GET";
17896 url;
17897 status = Requests.Response.status_code response;
17898 body;
17899 parsed_body;
17900 })
17901
17902 (** Update my preferences
17903
17904 Update the preferences of the current user. *)
17905 let update_my_preferences ~body client () =
17906 let op_name = "update_my_preferences" in
17907 let url_path = "/users/me/preferences" in
17908 let query = "" in
17909 let url = client.base_url ^ url_path ^ query in
17910 let response =
17911 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
17912 with Eio.Io _ as ex ->
17913 let bt = Printexc.get_raw_backtrace () in
17914 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
17915 in
17916 if Requests.Response.ok response then
17917 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
17918 else
17919 let body = Requests.Response.text response in
17920 let parsed_body =
17921 match Jsont_bytesrw.decode_string Jsont.json body with
17922 | Ok json -> Some (Openapi.Runtime.Json json)
17923 | Error _ -> Some (Openapi.Runtime.Raw body)
17924 in
17925 raise (Openapi.Runtime.Api_error {
17926 operation = op_name;
17927 method_ = "PUT";
17928 url;
17929 status = Requests.Response.status_code response;
17930 body;
17931 parsed_body;
17932 })
17933end
17934
17935module Person = struct
17936 module Types = struct
17937 module UpdateDto = struct
17938 type t = {
17939 birth_date : string option; (** Person date of birth.
17940 Note: the mobile app cannot currently set the birth date to null. *)
17941 color : string option;
17942 feature_face_asset_id : string option; (** Asset is used to get the feature face thumbnail. *)
17943 is_favorite : bool option;
17944 is_hidden : bool option; (** Person visibility *)
17945 name : string option; (** Person name. *)
17946 }
17947 end
17948
17949 module ResponseDto = struct
17950 type t = {
17951 birth_date : string option;
17952 color : string option;
17953 id : string;
17954 is_favorite : bool option;
17955 is_hidden : bool;
17956 name : string;
17957 thumbnail_path : string;
17958 updated_at : Ptime.t option;
17959 }
17960 end
17961
17962 module CreateDto = struct
17963 type t = {
17964 birth_date : string option; (** Person date of birth.
17965 Note: the mobile app cannot currently set the birth date to null. *)
17966 color : string option;
17967 is_favorite : bool option;
17968 is_hidden : bool option; (** Person visibility *)
17969 name : string option; (** Person name. *)
17970 }
17971 end
17972 end
17973
17974 module UpdateDto = struct
17975 include Types.UpdateDto
17976
17977 let v ?birth_date ?color ?feature_face_asset_id ?is_favorite ?is_hidden ?name () = { birth_date; color; feature_face_asset_id; is_favorite; is_hidden; name }
17978
17979 let birth_date t = t.birth_date
17980 let color t = t.color
17981 let feature_face_asset_id t = t.feature_face_asset_id
17982 let is_favorite t = t.is_favorite
17983 let is_hidden t = t.is_hidden
17984 let name t = t.name
17985
17986 let jsont : t Jsont.t =
17987 Jsont.Object.map ~kind:"PersonUpdateDto"
17988 (fun birth_date color feature_face_asset_id is_favorite is_hidden name -> { birth_date; color; feature_face_asset_id; is_favorite; is_hidden; name })
17989 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_string
17990 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
17991 |> Jsont.Object.mem "color" Openapi.Runtime.nullable_string
17992 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.color)
17993 |> Jsont.Object.opt_mem "featureFaceAssetId" Jsont.string ~enc:(fun r -> r.feature_face_asset_id)
17994 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
17995 |> Jsont.Object.opt_mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
17996 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
17997 |> Jsont.Object.skip_unknown
17998 |> Jsont.Object.finish
17999 end
18000
18001 module ResponseDto = struct
18002 include Types.ResponseDto
18003
18004 let v ~id ~is_hidden ~name ~thumbnail_path ?birth_date ?color ?is_favorite ?updated_at () = { birth_date; color; id; is_favorite; is_hidden; name; thumbnail_path; updated_at }
18005
18006 let birth_date t = t.birth_date
18007 let color t = t.color
18008 let id t = t.id
18009 let is_favorite t = t.is_favorite
18010 let is_hidden t = t.is_hidden
18011 let name t = t.name
18012 let thumbnail_path t = t.thumbnail_path
18013 let updated_at t = t.updated_at
18014
18015 let jsont : t Jsont.t =
18016 Jsont.Object.map ~kind:"PersonResponseDto"
18017 (fun birth_date color id is_favorite is_hidden name thumbnail_path updated_at -> { birth_date; color; id; is_favorite; is_hidden; name; thumbnail_path; updated_at })
18018 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_string
18019 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
18020 |> Jsont.Object.opt_mem "color" Jsont.string ~enc:(fun r -> r.color)
18021 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
18022 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
18023 |> Jsont.Object.mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
18024 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
18025 |> Jsont.Object.mem "thumbnailPath" Jsont.string ~enc:(fun r -> r.thumbnail_path)
18026 |> Jsont.Object.opt_mem "updatedAt" Openapi.Runtime.ptime_jsont ~enc:(fun r -> r.updated_at)
18027 |> Jsont.Object.skip_unknown
18028 |> Jsont.Object.finish
18029 end
18030
18031 module CreateDto = struct
18032 include Types.CreateDto
18033
18034 let v ?birth_date ?color ?is_favorite ?is_hidden ?name () = { birth_date; color; is_favorite; is_hidden; name }
18035
18036 let birth_date t = t.birth_date
18037 let color t = t.color
18038 let is_favorite t = t.is_favorite
18039 let is_hidden t = t.is_hidden
18040 let name t = t.name
18041
18042 let jsont : t Jsont.t =
18043 Jsont.Object.map ~kind:"PersonCreateDto"
18044 (fun birth_date color is_favorite is_hidden name -> { birth_date; color; is_favorite; is_hidden; name })
18045 |> Jsont.Object.mem "birthDate" Openapi.Runtime.nullable_string
18046 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.birth_date)
18047 |> Jsont.Object.mem "color" Openapi.Runtime.nullable_string
18048 ~dec_absent:None ~enc_omit:Option.is_none ~enc:(fun r -> r.color)
18049 |> Jsont.Object.opt_mem "isFavorite" Jsont.bool ~enc:(fun r -> r.is_favorite)
18050 |> Jsont.Object.opt_mem "isHidden" Jsont.bool ~enc:(fun r -> r.is_hidden)
18051 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
18052 |> Jsont.Object.skip_unknown
18053 |> Jsont.Object.finish
18054 end
18055
18056 (** Re-assign a face to another person
18057
18058 Re-assign the face provided in the body to the person identified by the id in the path parameter. *)
18059 let reassign_faces_by_id ~id ~body client () =
18060 let op_name = "reassign_faces_by_id" in
18061 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/faces/{id}" in
18062 let query = "" in
18063 let url = client.base_url ^ url_path ^ query in
18064 let response =
18065 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Face.Dto.jsont body)) url
18066 with Eio.Io _ as ex ->
18067 let bt = Printexc.get_raw_backtrace () in
18068 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18069 in
18070 if Requests.Response.ok response then
18071 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18072 else
18073 let body = Requests.Response.text response in
18074 let parsed_body =
18075 match Jsont_bytesrw.decode_string Jsont.json body with
18076 | Ok json -> Some (Openapi.Runtime.Json json)
18077 | Error _ -> Some (Openapi.Runtime.Raw body)
18078 in
18079 raise (Openapi.Runtime.Api_error {
18080 operation = op_name;
18081 method_ = "PUT";
18082 url;
18083 status = Requests.Response.status_code response;
18084 body;
18085 parsed_body;
18086 })
18087
18088 (** Create a person
18089
18090 Create a new person that can have multiple faces assigned to them. *)
18091 let create_person ~body client () =
18092 let op_name = "create_person" in
18093 let url_path = "/people" in
18094 let query = "" in
18095 let url = client.base_url ^ url_path ^ query in
18096 let response =
18097 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json CreateDto.jsont body)) url
18098 with Eio.Io _ as ex ->
18099 let bt = Printexc.get_raw_backtrace () in
18100 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
18101 in
18102 if Requests.Response.ok response then
18103 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18104 else
18105 let body = Requests.Response.text response in
18106 let parsed_body =
18107 match Jsont_bytesrw.decode_string Jsont.json body with
18108 | Ok json -> Some (Openapi.Runtime.Json json)
18109 | Error _ -> Some (Openapi.Runtime.Raw body)
18110 in
18111 raise (Openapi.Runtime.Api_error {
18112 operation = op_name;
18113 method_ = "POST";
18114 url;
18115 status = Requests.Response.status_code response;
18116 body;
18117 parsed_body;
18118 })
18119
18120 (** Get a person
18121
18122 Retrieve a person by id. *)
18123 let get_person ~id client () =
18124 let op_name = "get_person" in
18125 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}" in
18126 let query = "" in
18127 let url = client.base_url ^ url_path ^ query in
18128 let response =
18129 try Requests.get client.session url
18130 with Eio.Io _ as ex ->
18131 let bt = Printexc.get_raw_backtrace () in
18132 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
18133 in
18134 if Requests.Response.ok response then
18135 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18136 else
18137 let body = Requests.Response.text response in
18138 let parsed_body =
18139 match Jsont_bytesrw.decode_string Jsont.json body with
18140 | Ok json -> Some (Openapi.Runtime.Json json)
18141 | Error _ -> Some (Openapi.Runtime.Raw body)
18142 in
18143 raise (Openapi.Runtime.Api_error {
18144 operation = op_name;
18145 method_ = "GET";
18146 url;
18147 status = Requests.Response.status_code response;
18148 body;
18149 parsed_body;
18150 })
18151
18152 (** Update person
18153
18154 Update an individual person. *)
18155 let update_person ~id ~body client () =
18156 let op_name = "update_person" in
18157 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}" in
18158 let query = "" in
18159 let url = client.base_url ^ url_path ^ query in
18160 let response =
18161 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateDto.jsont body)) url
18162 with Eio.Io _ as ex ->
18163 let bt = Printexc.get_raw_backtrace () in
18164 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18165 in
18166 if Requests.Response.ok response then
18167 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18168 else
18169 let body = Requests.Response.text response in
18170 let parsed_body =
18171 match Jsont_bytesrw.decode_string Jsont.json body with
18172 | Ok json -> Some (Openapi.Runtime.Json json)
18173 | Error _ -> Some (Openapi.Runtime.Raw body)
18174 in
18175 raise (Openapi.Runtime.Api_error {
18176 operation = op_name;
18177 method_ = "PUT";
18178 url;
18179 status = Requests.Response.status_code response;
18180 body;
18181 parsed_body;
18182 })
18183
18184 (** Reassign faces
18185
18186 Bulk reassign a list of faces to a different person. *)
18187 let reassign_faces ~id ~body client () =
18188 let op_name = "reassign_faces" in
18189 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}/reassign" in
18190 let query = "" in
18191 let url = client.base_url ^ url_path ^ query in
18192 let response =
18193 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Jsont.json body)) url
18194 with Eio.Io _ as ex ->
18195 let bt = Printexc.get_raw_backtrace () in
18196 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18197 in
18198 if Requests.Response.ok response then
18199 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18200 else
18201 let body = Requests.Response.text response in
18202 let parsed_body =
18203 match Jsont_bytesrw.decode_string Jsont.json body with
18204 | Ok json -> Some (Openapi.Runtime.Json json)
18205 | Error _ -> Some (Openapi.Runtime.Raw body)
18206 in
18207 raise (Openapi.Runtime.Api_error {
18208 operation = op_name;
18209 method_ = "PUT";
18210 url;
18211 status = Requests.Response.status_code response;
18212 body;
18213 parsed_body;
18214 })
18215
18216 (** Search people
18217
18218 Search for people by name. *)
18219 let search_person ~name ?with_hidden client () =
18220 let op_name = "search_person" in
18221 let url_path = "/search/person" in
18222 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"name" ~value:name; Openapi.Runtime.Query.optional ~key:"withHidden" ~value:with_hidden]) in
18223 let url = client.base_url ^ url_path ^ query in
18224 let response =
18225 try Requests.get client.session url
18226 with Eio.Io _ as ex ->
18227 let bt = Printexc.get_raw_backtrace () in
18228 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
18229 in
18230 if Requests.Response.ok response then
18231 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18232 else
18233 let body = Requests.Response.text response in
18234 let parsed_body =
18235 match Jsont_bytesrw.decode_string Jsont.json body with
18236 | Ok json -> Some (Openapi.Runtime.Json json)
18237 | Error _ -> Some (Openapi.Runtime.Raw body)
18238 in
18239 raise (Openapi.Runtime.Api_error {
18240 operation = op_name;
18241 method_ = "GET";
18242 url;
18243 status = Requests.Response.status_code response;
18244 body;
18245 parsed_body;
18246 })
18247end
18248
18249module People = struct
18250 module Types = struct
18251 module UpdateDto = struct
18252 type t = {
18253 people : PeopleUpdate.Item.t list;
18254 }
18255 end
18256
18257 module Update = struct
18258 type t = {
18259 enabled : bool option;
18260 sidebar_web : bool option;
18261 }
18262 end
18263
18264 module ResponseDto = struct
18265 type t = {
18266 has_next_page : bool option;
18267 hidden : int;
18268 people : Person.ResponseDto.t list;
18269 total : int;
18270 }
18271 end
18272
18273 module Response = struct
18274 type t = {
18275 enabled : bool;
18276 sidebar_web : bool;
18277 }
18278 end
18279 end
18280
18281 module UpdateDto = struct
18282 include Types.UpdateDto
18283
18284 let v ~people () = { people }
18285
18286 let people t = t.people
18287
18288 let jsont : t Jsont.t =
18289 Jsont.Object.map ~kind:"PeopleUpdateDto"
18290 (fun people -> { people })
18291 |> Jsont.Object.mem "people" (Jsont.list PeopleUpdate.Item.jsont) ~enc:(fun r -> r.people)
18292 |> Jsont.Object.skip_unknown
18293 |> Jsont.Object.finish
18294 end
18295
18296 module Update = struct
18297 include Types.Update
18298
18299 let v ?enabled ?sidebar_web () = { enabled; sidebar_web }
18300
18301 let enabled t = t.enabled
18302 let sidebar_web t = t.sidebar_web
18303
18304 let jsont : t Jsont.t =
18305 Jsont.Object.map ~kind:"PeopleUpdate"
18306 (fun enabled sidebar_web -> { enabled; sidebar_web })
18307 |> Jsont.Object.opt_mem "enabled" Jsont.bool ~enc:(fun r -> r.enabled)
18308 |> Jsont.Object.opt_mem "sidebarWeb" Jsont.bool ~enc:(fun r -> r.sidebar_web)
18309 |> Jsont.Object.skip_unknown
18310 |> Jsont.Object.finish
18311 end
18312
18313 module ResponseDto = struct
18314 include Types.ResponseDto
18315
18316 let v ~hidden ~people ~total ?has_next_page () = { has_next_page; hidden; people; total }
18317
18318 let has_next_page t = t.has_next_page
18319 let hidden t = t.hidden
18320 let people t = t.people
18321 let total t = t.total
18322
18323 let jsont : t Jsont.t =
18324 Jsont.Object.map ~kind:"PeopleResponseDto"
18325 (fun has_next_page hidden people total -> { has_next_page; hidden; people; total })
18326 |> Jsont.Object.opt_mem "hasNextPage" Jsont.bool ~enc:(fun r -> r.has_next_page)
18327 |> Jsont.Object.mem "hidden" Jsont.int ~enc:(fun r -> r.hidden)
18328 |> Jsont.Object.mem "people" (Jsont.list Person.ResponseDto.jsont) ~enc:(fun r -> r.people)
18329 |> Jsont.Object.mem "total" Jsont.int ~enc:(fun r -> r.total)
18330 |> Jsont.Object.skip_unknown
18331 |> Jsont.Object.finish
18332 end
18333
18334 module Response = struct
18335 include Types.Response
18336
18337 let v ?(enabled=true) ?(sidebar_web=false) () = { enabled; sidebar_web }
18338
18339 let enabled t = t.enabled
18340 let sidebar_web t = t.sidebar_web
18341
18342 let jsont : t Jsont.t =
18343 Jsont.Object.map ~kind:"PeopleResponse"
18344 (fun enabled sidebar_web -> { enabled; sidebar_web })
18345 |> Jsont.Object.mem "enabled" Jsont.bool ~dec_absent:true ~enc:(fun r -> r.enabled)
18346 |> Jsont.Object.mem "sidebarWeb" Jsont.bool ~dec_absent:false ~enc:(fun r -> r.sidebar_web)
18347 |> Jsont.Object.skip_unknown
18348 |> Jsont.Object.finish
18349 end
18350
18351 (** Get all people
18352
18353 Retrieve a list of all people.
18354 @param page Page number for pagination
18355 @param size Number of items per page
18356 *)
18357 let get_all_people ?closest_asset_id ?closest_person_id ?page ?size ?with_hidden client () =
18358 let op_name = "get_all_people" in
18359 let url_path = "/people" in
18360 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"closestAssetId" ~value:closest_asset_id; Openapi.Runtime.Query.optional ~key:"closestPersonId" ~value:closest_person_id; Openapi.Runtime.Query.optional ~key:"page" ~value:page; Openapi.Runtime.Query.optional ~key:"size" ~value:size; Openapi.Runtime.Query.optional ~key:"withHidden" ~value:with_hidden]) in
18361 let url = client.base_url ^ url_path ^ query in
18362 let response =
18363 try Requests.get client.session url
18364 with Eio.Io _ as ex ->
18365 let bt = Printexc.get_raw_backtrace () in
18366 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
18367 in
18368 if Requests.Response.ok response then
18369 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18370 else
18371 let body = Requests.Response.text response in
18372 let parsed_body =
18373 match Jsont_bytesrw.decode_string Jsont.json body with
18374 | Ok json -> Some (Openapi.Runtime.Json json)
18375 | Error _ -> Some (Openapi.Runtime.Raw body)
18376 in
18377 raise (Openapi.Runtime.Api_error {
18378 operation = op_name;
18379 method_ = "GET";
18380 url;
18381 status = Requests.Response.status_code response;
18382 body;
18383 parsed_body;
18384 })
18385end
18386
18387module BulkId = struct
18388 module Types = struct
18389 module ResponseDto = struct
18390 type t = {
18391 error : string option;
18392 id : string;
18393 success : bool;
18394 }
18395 end
18396 end
18397
18398 module ResponseDto = struct
18399 include Types.ResponseDto
18400
18401 let v ~id ~success ?error () = { error; id; success }
18402
18403 let error t = t.error
18404 let id t = t.id
18405 let success t = t.success
18406
18407 let jsont : t Jsont.t =
18408 Jsont.Object.map ~kind:"BulkIdResponseDto"
18409 (fun error id success -> { error; id; success })
18410 |> Jsont.Object.opt_mem "error" Jsont.string ~enc:(fun r -> r.error)
18411 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
18412 |> Jsont.Object.mem "success" Jsont.bool ~enc:(fun r -> r.success)
18413 |> Jsont.Object.skip_unknown
18414 |> Jsont.Object.finish
18415 end
18416
18417 (** Add assets to an album
18418
18419 Add multiple assets to a specific album by its ID. *)
18420 let add_assets_to_album ~id ?key ?slug ~body client () =
18421 let op_name = "add_assets_to_album" in
18422 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}/assets" in
18423 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
18424 let url = client.base_url ^ url_path ^ query in
18425 let response =
18426 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json BulkIds.Dto.jsont body)) url
18427 with Eio.Io _ as ex ->
18428 let bt = Printexc.get_raw_backtrace () in
18429 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18430 in
18431 if Requests.Response.ok response then
18432 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18433 else
18434 let body = Requests.Response.text response in
18435 let parsed_body =
18436 match Jsont_bytesrw.decode_string Jsont.json body with
18437 | Ok json -> Some (Openapi.Runtime.Json json)
18438 | Error _ -> Some (Openapi.Runtime.Raw body)
18439 in
18440 raise (Openapi.Runtime.Api_error {
18441 operation = op_name;
18442 method_ = "PUT";
18443 url;
18444 status = Requests.Response.status_code response;
18445 body;
18446 parsed_body;
18447 })
18448
18449 (** Remove assets from an album
18450
18451 Remove multiple assets from a specific album by its ID. *)
18452 let remove_asset_from_album ~id client () =
18453 let op_name = "remove_asset_from_album" in
18454 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}/assets" in
18455 let query = "" in
18456 let url = client.base_url ^ url_path ^ query in
18457 let response =
18458 try Requests.delete client.session url
18459 with Eio.Io _ as ex ->
18460 let bt = Printexc.get_raw_backtrace () in
18461 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
18462 in
18463 if Requests.Response.ok response then
18464 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18465 else
18466 let body = Requests.Response.text response in
18467 let parsed_body =
18468 match Jsont_bytesrw.decode_string Jsont.json body with
18469 | Ok json -> Some (Openapi.Runtime.Json json)
18470 | Error _ -> Some (Openapi.Runtime.Raw body)
18471 in
18472 raise (Openapi.Runtime.Api_error {
18473 operation = op_name;
18474 method_ = "DELETE";
18475 url;
18476 status = Requests.Response.status_code response;
18477 body;
18478 parsed_body;
18479 })
18480
18481 (** Add assets to a memory
18482
18483 Add a list of asset IDs to a specific memory. *)
18484 let add_memory_assets ~id ~body client () =
18485 let op_name = "add_memory_assets" in
18486 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/memories/{id}/assets" in
18487 let query = "" in
18488 let url = client.base_url ^ url_path ^ query in
18489 let response =
18490 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json BulkIds.Dto.jsont body)) url
18491 with Eio.Io _ as ex ->
18492 let bt = Printexc.get_raw_backtrace () in
18493 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18494 in
18495 if Requests.Response.ok response then
18496 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18497 else
18498 let body = Requests.Response.text response in
18499 let parsed_body =
18500 match Jsont_bytesrw.decode_string Jsont.json body with
18501 | Ok json -> Some (Openapi.Runtime.Json json)
18502 | Error _ -> Some (Openapi.Runtime.Raw body)
18503 in
18504 raise (Openapi.Runtime.Api_error {
18505 operation = op_name;
18506 method_ = "PUT";
18507 url;
18508 status = Requests.Response.status_code response;
18509 body;
18510 parsed_body;
18511 })
18512
18513 (** Remove assets from a memory
18514
18515 Remove a list of asset IDs from a specific memory. *)
18516 let remove_memory_assets ~id client () =
18517 let op_name = "remove_memory_assets" in
18518 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/memories/{id}/assets" in
18519 let query = "" in
18520 let url = client.base_url ^ url_path ^ query in
18521 let response =
18522 try Requests.delete client.session url
18523 with Eio.Io _ as ex ->
18524 let bt = Printexc.get_raw_backtrace () in
18525 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
18526 in
18527 if Requests.Response.ok response then
18528 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18529 else
18530 let body = Requests.Response.text response in
18531 let parsed_body =
18532 match Jsont_bytesrw.decode_string Jsont.json body with
18533 | Ok json -> Some (Openapi.Runtime.Json json)
18534 | Error _ -> Some (Openapi.Runtime.Raw body)
18535 in
18536 raise (Openapi.Runtime.Api_error {
18537 operation = op_name;
18538 method_ = "DELETE";
18539 url;
18540 status = Requests.Response.status_code response;
18541 body;
18542 parsed_body;
18543 })
18544
18545 (** Update people
18546
18547 Bulk update multiple people at once. *)
18548 let update_people ~body client () =
18549 let op_name = "update_people" in
18550 let url_path = "/people" in
18551 let query = "" in
18552 let url = client.base_url ^ url_path ^ query in
18553 let response =
18554 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json People.UpdateDto.jsont body)) url
18555 with Eio.Io _ as ex ->
18556 let bt = Printexc.get_raw_backtrace () in
18557 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18558 in
18559 if Requests.Response.ok response then
18560 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18561 else
18562 let body = Requests.Response.text response in
18563 let parsed_body =
18564 match Jsont_bytesrw.decode_string Jsont.json body with
18565 | Ok json -> Some (Openapi.Runtime.Json json)
18566 | Error _ -> Some (Openapi.Runtime.Raw body)
18567 in
18568 raise (Openapi.Runtime.Api_error {
18569 operation = op_name;
18570 method_ = "PUT";
18571 url;
18572 status = Requests.Response.status_code response;
18573 body;
18574 parsed_body;
18575 })
18576
18577 (** Merge people
18578
18579 Merge a list of people into the person specified in the path parameter. *)
18580 let merge_person ~id ~body client () =
18581 let op_name = "merge_person" in
18582 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}/merge" in
18583 let query = "" in
18584 let url = client.base_url ^ url_path ^ query in
18585 let response =
18586 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json MergePerson.Dto.jsont body)) url
18587 with Eio.Io _ as ex ->
18588 let bt = Printexc.get_raw_backtrace () in
18589 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
18590 in
18591 if Requests.Response.ok response then
18592 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18593 else
18594 let body = Requests.Response.text response in
18595 let parsed_body =
18596 match Jsont_bytesrw.decode_string Jsont.json body with
18597 | Ok json -> Some (Openapi.Runtime.Json json)
18598 | Error _ -> Some (Openapi.Runtime.Raw body)
18599 in
18600 raise (Openapi.Runtime.Api_error {
18601 operation = op_name;
18602 method_ = "POST";
18603 url;
18604 status = Requests.Response.status_code response;
18605 body;
18606 parsed_body;
18607 })
18608
18609 (** Tag assets
18610
18611 Add a tag to all the specified assets. *)
18612 let tag_assets ~id ~body client () =
18613 let op_name = "tag_assets" in
18614 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/tags/{id}/assets" in
18615 let query = "" in
18616 let url = client.base_url ^ url_path ^ query in
18617 let response =
18618 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json BulkIds.Dto.jsont body)) url
18619 with Eio.Io _ as ex ->
18620 let bt = Printexc.get_raw_backtrace () in
18621 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
18622 in
18623 if Requests.Response.ok response then
18624 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18625 else
18626 let body = Requests.Response.text response in
18627 let parsed_body =
18628 match Jsont_bytesrw.decode_string Jsont.json body with
18629 | Ok json -> Some (Openapi.Runtime.Json json)
18630 | Error _ -> Some (Openapi.Runtime.Raw body)
18631 in
18632 raise (Openapi.Runtime.Api_error {
18633 operation = op_name;
18634 method_ = "PUT";
18635 url;
18636 status = Requests.Response.status_code response;
18637 body;
18638 parsed_body;
18639 })
18640
18641 (** Untag assets
18642
18643 Remove a tag from all the specified assets. *)
18644 let untag_assets ~id client () =
18645 let op_name = "untag_assets" in
18646 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/tags/{id}/assets" in
18647 let query = "" in
18648 let url = client.base_url ^ url_path ^ query in
18649 let response =
18650 try Requests.delete client.session url
18651 with Eio.Io _ as ex ->
18652 let bt = Printexc.get_raw_backtrace () in
18653 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
18654 in
18655 if Requests.Response.ok response then
18656 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18657 else
18658 let body = Requests.Response.text response in
18659 let parsed_body =
18660 match Jsont_bytesrw.decode_string Jsont.json body with
18661 | Ok json -> Some (Openapi.Runtime.Json json)
18662 | Error _ -> Some (Openapi.Runtime.Raw body)
18663 in
18664 raise (Openapi.Runtime.Api_error {
18665 operation = op_name;
18666 method_ = "DELETE";
18667 url;
18668 status = Requests.Response.status_code response;
18669 body;
18670 parsed_body;
18671 })
18672end
18673
18674module AssetFace = struct
18675 module Types = struct
18676 module UpdateDto = struct
18677 type t = {
18678 data : AssetFaceUpdate.Item.t list;
18679 }
18680 end
18681
18682 module ResponseDto = struct
18683 type t = {
18684 bounding_box_x1 : int;
18685 bounding_box_x2 : int;
18686 bounding_box_y1 : int;
18687 bounding_box_y2 : int;
18688 id : string;
18689 image_height : int;
18690 image_width : int;
18691 person : Person.ResponseDto.t;
18692 source_type : Source.Type.t option;
18693 }
18694 end
18695
18696 module CreateDto = struct
18697 type t = {
18698 asset_id : string;
18699 height : int;
18700 image_height : int;
18701 image_width : int;
18702 person_id : string;
18703 width : int;
18704 x : int;
18705 y : int;
18706 }
18707 end
18708 end
18709
18710 module UpdateDto = struct
18711 include Types.UpdateDto
18712
18713 let v ~data () = { data }
18714
18715 let data t = t.data
18716
18717 let jsont : t Jsont.t =
18718 Jsont.Object.map ~kind:"AssetFaceUpdateDto"
18719 (fun data -> { data })
18720 |> Jsont.Object.mem "data" (Jsont.list AssetFaceUpdate.Item.jsont) ~enc:(fun r -> r.data)
18721 |> Jsont.Object.skip_unknown
18722 |> Jsont.Object.finish
18723 end
18724
18725 module ResponseDto = struct
18726 include Types.ResponseDto
18727
18728 let v ~bounding_box_x1 ~bounding_box_x2 ~bounding_box_y1 ~bounding_box_y2 ~id ~image_height ~image_width ~person ?source_type () = { bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; person; source_type }
18729
18730 let bounding_box_x1 t = t.bounding_box_x1
18731 let bounding_box_x2 t = t.bounding_box_x2
18732 let bounding_box_y1 t = t.bounding_box_y1
18733 let bounding_box_y2 t = t.bounding_box_y2
18734 let id t = t.id
18735 let image_height t = t.image_height
18736 let image_width t = t.image_width
18737 let person t = t.person
18738 let source_type t = t.source_type
18739
18740 let jsont : t Jsont.t =
18741 Jsont.Object.map ~kind:"AssetFaceResponseDto"
18742 (fun bounding_box_x1 bounding_box_x2 bounding_box_y1 bounding_box_y2 id image_height image_width person source_type -> { bounding_box_x1; bounding_box_x2; bounding_box_y1; bounding_box_y2; id; image_height; image_width; person; source_type })
18743 |> Jsont.Object.mem "boundingBoxX1" Jsont.int ~enc:(fun r -> r.bounding_box_x1)
18744 |> Jsont.Object.mem "boundingBoxX2" Jsont.int ~enc:(fun r -> r.bounding_box_x2)
18745 |> Jsont.Object.mem "boundingBoxY1" Jsont.int ~enc:(fun r -> r.bounding_box_y1)
18746 |> Jsont.Object.mem "boundingBoxY2" Jsont.int ~enc:(fun r -> r.bounding_box_y2)
18747 |> Jsont.Object.mem "id" Jsont.string ~enc:(fun r -> r.id)
18748 |> Jsont.Object.mem "imageHeight" Jsont.int ~enc:(fun r -> r.image_height)
18749 |> Jsont.Object.mem "imageWidth" Jsont.int ~enc:(fun r -> r.image_width)
18750 |> Jsont.Object.mem "person" Person.ResponseDto.jsont ~enc:(fun r -> r.person)
18751 |> Jsont.Object.opt_mem "sourceType" Source.Type.jsont ~enc:(fun r -> r.source_type)
18752 |> Jsont.Object.skip_unknown
18753 |> Jsont.Object.finish
18754 end
18755
18756 module CreateDto = struct
18757 include Types.CreateDto
18758
18759 let v ~asset_id ~height ~image_height ~image_width ~person_id ~width ~x ~y () = { asset_id; height; image_height; image_width; person_id; width; x; y }
18760
18761 let asset_id t = t.asset_id
18762 let height t = t.height
18763 let image_height t = t.image_height
18764 let image_width t = t.image_width
18765 let person_id t = t.person_id
18766 let width t = t.width
18767 let x t = t.x
18768 let y t = t.y
18769
18770 let jsont : t Jsont.t =
18771 Jsont.Object.map ~kind:"AssetFaceCreateDto"
18772 (fun asset_id height image_height image_width person_id width x y -> { asset_id; height; image_height; image_width; person_id; width; x; y })
18773 |> Jsont.Object.mem "assetId" Jsont.string ~enc:(fun r -> r.asset_id)
18774 |> Jsont.Object.mem "height" Jsont.int ~enc:(fun r -> r.height)
18775 |> Jsont.Object.mem "imageHeight" Jsont.int ~enc:(fun r -> r.image_height)
18776 |> Jsont.Object.mem "imageWidth" Jsont.int ~enc:(fun r -> r.image_width)
18777 |> Jsont.Object.mem "personId" Jsont.string ~enc:(fun r -> r.person_id)
18778 |> Jsont.Object.mem "width" Jsont.int ~enc:(fun r -> r.width)
18779 |> Jsont.Object.mem "x" Jsont.int ~enc:(fun r -> r.x)
18780 |> Jsont.Object.mem "y" Jsont.int ~enc:(fun r -> r.y)
18781 |> Jsont.Object.skip_unknown
18782 |> Jsont.Object.finish
18783 end
18784
18785 (** Retrieve faces for asset
18786
18787 Retrieve all faces belonging to an asset. *)
18788 let get_faces ~id client () =
18789 let op_name = "get_faces" in
18790 let url_path = "/faces" in
18791 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.singleton ~key:"id" ~value:id]) in
18792 let url = client.base_url ^ url_path ^ query in
18793 let response =
18794 try Requests.get client.session url
18795 with Eio.Io _ as ex ->
18796 let bt = Printexc.get_raw_backtrace () in
18797 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
18798 in
18799 if Requests.Response.ok response then
18800 Openapi.Runtime.Json.decode_json_exn ResponseDto.jsont (Requests.Response.json response)
18801 else
18802 let body = Requests.Response.text response in
18803 let parsed_body =
18804 match Jsont_bytesrw.decode_string Jsont.json body with
18805 | Ok json -> Some (Openapi.Runtime.Json json)
18806 | Error _ -> Some (Openapi.Runtime.Raw body)
18807 in
18808 raise (Openapi.Runtime.Api_error {
18809 operation = op_name;
18810 method_ = "GET";
18811 url;
18812 status = Requests.Response.status_code response;
18813 body;
18814 parsed_body;
18815 })
18816end
18817
18818module Client = struct
18819 (** Delete an activity
18820
18821 Removes a like or comment from a given album or asset in an album. *)
18822 let delete_activity ~id client () =
18823 let op_name = "delete_activity" in
18824 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/activities/{id}" in
18825 let query = "" in
18826 let url = client.base_url ^ url_path ^ query in
18827 let response =
18828 try Requests.delete client.session url
18829 with Eio.Io _ as ex ->
18830 let bt = Printexc.get_raw_backtrace () in
18831 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
18832 in
18833 if Requests.Response.ok response then
18834 Requests.Response.json response
18835 else
18836 let body = Requests.Response.text response in
18837 let parsed_body =
18838 match Jsont_bytesrw.decode_string Jsont.json body with
18839 | Ok json -> Some (Openapi.Runtime.Json json)
18840 | Error _ -> Some (Openapi.Runtime.Raw body)
18841 in
18842 raise (Openapi.Runtime.Api_error {
18843 operation = op_name;
18844 method_ = "DELETE";
18845 url;
18846 status = Requests.Response.status_code response;
18847 body;
18848 parsed_body;
18849 })
18850
18851 (** Unlink all OAuth accounts
18852
18853 Unlinks all OAuth accounts associated with user accounts in the system. *)
18854 let unlink_all_oauth_accounts_admin client () =
18855 let op_name = "unlink_all_oauth_accounts_admin" in
18856 let url_path = "/admin/auth/unlink-all" in
18857 let query = "" in
18858 let url = client.base_url ^ url_path ^ query in
18859 let response =
18860 try Requests.post client.session url
18861 with Eio.Io _ as ex ->
18862 let bt = Printexc.get_raw_backtrace () in
18863 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
18864 in
18865 if Requests.Response.ok response then
18866 Requests.Response.json response
18867 else
18868 let body = Requests.Response.text response in
18869 let parsed_body =
18870 match Jsont_bytesrw.decode_string Jsont.json body with
18871 | Ok json -> Some (Openapi.Runtime.Json json)
18872 | Error _ -> Some (Openapi.Runtime.Raw body)
18873 in
18874 raise (Openapi.Runtime.Api_error {
18875 operation = op_name;
18876 method_ = "POST";
18877 url;
18878 status = Requests.Response.status_code response;
18879 body;
18880 parsed_body;
18881 })
18882
18883 (** Delete database backup
18884
18885 Delete a backup by its filename *)
18886 let delete_database_backup client () =
18887 let op_name = "delete_database_backup" in
18888 let url_path = "/admin/database-backups" in
18889 let query = "" in
18890 let url = client.base_url ^ url_path ^ query in
18891 let response =
18892 try Requests.delete client.session url
18893 with Eio.Io _ as ex ->
18894 let bt = Printexc.get_raw_backtrace () in
18895 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
18896 in
18897 if Requests.Response.ok response then
18898 Requests.Response.json response
18899 else
18900 let body = Requests.Response.text response in
18901 let parsed_body =
18902 match Jsont_bytesrw.decode_string Jsont.json body with
18903 | Ok json -> Some (Openapi.Runtime.Json json)
18904 | Error _ -> Some (Openapi.Runtime.Raw body)
18905 in
18906 raise (Openapi.Runtime.Api_error {
18907 operation = op_name;
18908 method_ = "DELETE";
18909 url;
18910 status = Requests.Response.status_code response;
18911 body;
18912 parsed_body;
18913 })
18914
18915 (** Start database backup restore flow
18916
18917 Put Immich into maintenance mode to restore a backup (Immich must not be configured) *)
18918 let start_database_restore_flow client () =
18919 let op_name = "start_database_restore_flow" in
18920 let url_path = "/admin/database-backups/start-restore" in
18921 let query = "" in
18922 let url = client.base_url ^ url_path ^ query in
18923 let response =
18924 try Requests.post client.session url
18925 with Eio.Io _ as ex ->
18926 let bt = Printexc.get_raw_backtrace () in
18927 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
18928 in
18929 if Requests.Response.ok response then
18930 Requests.Response.json response
18931 else
18932 let body = Requests.Response.text response in
18933 let parsed_body =
18934 match Jsont_bytesrw.decode_string Jsont.json body with
18935 | Ok json -> Some (Openapi.Runtime.Json json)
18936 | Error _ -> Some (Openapi.Runtime.Raw body)
18937 in
18938 raise (Openapi.Runtime.Api_error {
18939 operation = op_name;
18940 method_ = "POST";
18941 url;
18942 status = Requests.Response.status_code response;
18943 body;
18944 parsed_body;
18945 })
18946
18947 (** Upload database backup
18948
18949 Uploads .sql/.sql.gz file to restore backup from *)
18950 let upload_database_backup client () =
18951 let op_name = "upload_database_backup" in
18952 let url_path = "/admin/database-backups/upload" in
18953 let query = "" in
18954 let url = client.base_url ^ url_path ^ query in
18955 let response =
18956 try Requests.post client.session url
18957 with Eio.Io _ as ex ->
18958 let bt = Printexc.get_raw_backtrace () in
18959 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
18960 in
18961 if Requests.Response.ok response then
18962 Requests.Response.json response
18963 else
18964 let body = Requests.Response.text response in
18965 let parsed_body =
18966 match Jsont_bytesrw.decode_string Jsont.json body with
18967 | Ok json -> Some (Openapi.Runtime.Json json)
18968 | Error _ -> Some (Openapi.Runtime.Raw body)
18969 in
18970 raise (Openapi.Runtime.Api_error {
18971 operation = op_name;
18972 method_ = "POST";
18973 url;
18974 status = Requests.Response.status_code response;
18975 body;
18976 parsed_body;
18977 })
18978
18979 (** Download database backup
18980
18981 Downloads the database backup file *)
18982 let download_database_backup ~filename client () =
18983 let op_name = "download_database_backup" in
18984 let url_path = Openapi.Runtime.Path.render ~params:[("filename", filename)] "/admin/database-backups/{filename}" in
18985 let query = "" in
18986 let url = client.base_url ^ url_path ^ query in
18987 let response =
18988 try Requests.get client.session url
18989 with Eio.Io _ as ex ->
18990 let bt = Printexc.get_raw_backtrace () in
18991 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
18992 in
18993 if Requests.Response.ok response then
18994 Requests.Response.json response
18995 else
18996 let body = Requests.Response.text response in
18997 let parsed_body =
18998 match Jsont_bytesrw.decode_string Jsont.json body with
18999 | Ok json -> Some (Openapi.Runtime.Json json)
19000 | Error _ -> Some (Openapi.Runtime.Raw body)
19001 in
19002 raise (Openapi.Runtime.Api_error {
19003 operation = op_name;
19004 method_ = "GET";
19005 url;
19006 status = Requests.Response.status_code response;
19007 body;
19008 parsed_body;
19009 })
19010
19011 (** Set maintenance mode
19012
19013 Put Immich into or take it out of maintenance mode *)
19014 let set_maintenance_mode ~body client () =
19015 let op_name = "set_maintenance_mode" in
19016 let url_path = "/admin/maintenance" in
19017 let query = "" in
19018 let url = client.base_url ^ url_path ^ query in
19019 let response =
19020 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SetMaintenanceMode.Dto.jsont body)) url
19021 with Eio.Io _ as ex ->
19022 let bt = Printexc.get_raw_backtrace () in
19023 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19024 in
19025 if Requests.Response.ok response then
19026 Requests.Response.json response
19027 else
19028 let body = Requests.Response.text response in
19029 let parsed_body =
19030 match Jsont_bytesrw.decode_string Jsont.json body with
19031 | Ok json -> Some (Openapi.Runtime.Json json)
19032 | Error _ -> Some (Openapi.Runtime.Raw body)
19033 in
19034 raise (Openapi.Runtime.Api_error {
19035 operation = op_name;
19036 method_ = "POST";
19037 url;
19038 status = Requests.Response.status_code response;
19039 body;
19040 parsed_body;
19041 })
19042
19043 (** Delete an album
19044
19045 Delete a specific album by its ID. Note the album is initially trashed and then immediately scheduled for deletion, but relies on a background job to complete the process. *)
19046 let delete_album ~id client () =
19047 let op_name = "delete_album" in
19048 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/albums/{id}" in
19049 let query = "" in
19050 let url = client.base_url ^ url_path ^ query in
19051 let response =
19052 try Requests.delete client.session url
19053 with Eio.Io _ as ex ->
19054 let bt = Printexc.get_raw_backtrace () in
19055 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19056 in
19057 if Requests.Response.ok response then
19058 Requests.Response.json response
19059 else
19060 let body = Requests.Response.text response in
19061 let parsed_body =
19062 match Jsont_bytesrw.decode_string Jsont.json body with
19063 | Ok json -> Some (Openapi.Runtime.Json json)
19064 | Error _ -> Some (Openapi.Runtime.Raw body)
19065 in
19066 raise (Openapi.Runtime.Api_error {
19067 operation = op_name;
19068 method_ = "DELETE";
19069 url;
19070 status = Requests.Response.status_code response;
19071 body;
19072 parsed_body;
19073 })
19074
19075 (** Update user role
19076
19077 Change the role for a specific user in a specific album. *)
19078 let update_album_user ~id ~user_id ~body client () =
19079 let op_name = "update_album_user" in
19080 let url_path = Openapi.Runtime.Path.render ~params:[("id", id); ("userId", user_id)] "/albums/{id}/user/{userId}" in
19081 let query = "" in
19082 let url = client.base_url ^ url_path ^ query in
19083 let response =
19084 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json UpdateAlbumUser.Dto.jsont body)) url
19085 with Eio.Io _ as ex ->
19086 let bt = Printexc.get_raw_backtrace () in
19087 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
19088 in
19089 if Requests.Response.ok response then
19090 Requests.Response.json response
19091 else
19092 let body = Requests.Response.text response in
19093 let parsed_body =
19094 match Jsont_bytesrw.decode_string Jsont.json body with
19095 | Ok json -> Some (Openapi.Runtime.Json json)
19096 | Error _ -> Some (Openapi.Runtime.Raw body)
19097 in
19098 raise (Openapi.Runtime.Api_error {
19099 operation = op_name;
19100 method_ = "PUT";
19101 url;
19102 status = Requests.Response.status_code response;
19103 body;
19104 parsed_body;
19105 })
19106
19107 (** Remove user from album
19108
19109 Remove a user from an album. Use an ID of "me" to leave a shared album. *)
19110 let remove_user_from_album ~id ~user_id client () =
19111 let op_name = "remove_user_from_album" in
19112 let url_path = Openapi.Runtime.Path.render ~params:[("id", id); ("userId", user_id)] "/albums/{id}/user/{userId}" in
19113 let query = "" in
19114 let url = client.base_url ^ url_path ^ query in
19115 let response =
19116 try Requests.delete client.session url
19117 with Eio.Io _ as ex ->
19118 let bt = Printexc.get_raw_backtrace () in
19119 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19120 in
19121 if Requests.Response.ok response then
19122 Requests.Response.json response
19123 else
19124 let body = Requests.Response.text response in
19125 let parsed_body =
19126 match Jsont_bytesrw.decode_string Jsont.json body with
19127 | Ok json -> Some (Openapi.Runtime.Json json)
19128 | Error _ -> Some (Openapi.Runtime.Raw body)
19129 in
19130 raise (Openapi.Runtime.Api_error {
19131 operation = op_name;
19132 method_ = "DELETE";
19133 url;
19134 status = Requests.Response.status_code response;
19135 body;
19136 parsed_body;
19137 })
19138
19139 (** Delete an API key
19140
19141 Deletes an API key identified by its ID. The current user must own this API key. *)
19142 let delete_api_key ~id client () =
19143 let op_name = "delete_api_key" in
19144 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/api-keys/{id}" in
19145 let query = "" in
19146 let url = client.base_url ^ url_path ^ query in
19147 let response =
19148 try Requests.delete client.session url
19149 with Eio.Io _ as ex ->
19150 let bt = Printexc.get_raw_backtrace () in
19151 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19152 in
19153 if Requests.Response.ok response then
19154 Requests.Response.json response
19155 else
19156 let body = Requests.Response.text response in
19157 let parsed_body =
19158 match Jsont_bytesrw.decode_string Jsont.json body with
19159 | Ok json -> Some (Openapi.Runtime.Json json)
19160 | Error _ -> Some (Openapi.Runtime.Raw body)
19161 in
19162 raise (Openapi.Runtime.Api_error {
19163 operation = op_name;
19164 method_ = "DELETE";
19165 url;
19166 status = Requests.Response.status_code response;
19167 body;
19168 parsed_body;
19169 })
19170
19171 (** Update assets
19172
19173 Updates multiple assets at the same time. *)
19174 let update_assets ~body client () =
19175 let op_name = "update_assets" in
19176 let url_path = "/assets" in
19177 let query = "" in
19178 let url = client.base_url ^ url_path ^ query in
19179 let response =
19180 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetBulk.UpdateDto.jsont body)) url
19181 with Eio.Io _ as ex ->
19182 let bt = Printexc.get_raw_backtrace () in
19183 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
19184 in
19185 if Requests.Response.ok response then
19186 Requests.Response.json response
19187 else
19188 let body = Requests.Response.text response in
19189 let parsed_body =
19190 match Jsont_bytesrw.decode_string Jsont.json body with
19191 | Ok json -> Some (Openapi.Runtime.Json json)
19192 | Error _ -> Some (Openapi.Runtime.Raw body)
19193 in
19194 raise (Openapi.Runtime.Api_error {
19195 operation = op_name;
19196 method_ = "PUT";
19197 url;
19198 status = Requests.Response.status_code response;
19199 body;
19200 parsed_body;
19201 })
19202
19203 (** Delete assets
19204
19205 Deletes multiple assets at the same time. *)
19206 let delete_assets client () =
19207 let op_name = "delete_assets" in
19208 let url_path = "/assets" in
19209 let query = "" in
19210 let url = client.base_url ^ url_path ^ query in
19211 let response =
19212 try Requests.delete client.session url
19213 with Eio.Io _ as ex ->
19214 let bt = Printexc.get_raw_backtrace () in
19215 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19216 in
19217 if Requests.Response.ok response then
19218 Requests.Response.json response
19219 else
19220 let body = Requests.Response.text response in
19221 let parsed_body =
19222 match Jsont_bytesrw.decode_string Jsont.json body with
19223 | Ok json -> Some (Openapi.Runtime.Json json)
19224 | Error _ -> Some (Openapi.Runtime.Raw body)
19225 in
19226 raise (Openapi.Runtime.Api_error {
19227 operation = op_name;
19228 method_ = "DELETE";
19229 url;
19230 status = Requests.Response.status_code response;
19231 body;
19232 parsed_body;
19233 })
19234
19235 (** Copy asset
19236
19237 Copy asset information like albums, tags, etc. from one asset to another. *)
19238 let copy_asset ~body client () =
19239 let op_name = "copy_asset" in
19240 let url_path = "/assets/copy" in
19241 let query = "" in
19242 let url = client.base_url ^ url_path ^ query in
19243 let response =
19244 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetCopy.Dto.jsont body)) url
19245 with Eio.Io _ as ex ->
19246 let bt = Printexc.get_raw_backtrace () in
19247 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
19248 in
19249 if Requests.Response.ok response then
19250 Requests.Response.json response
19251 else
19252 let body = Requests.Response.text response in
19253 let parsed_body =
19254 match Jsont_bytesrw.decode_string Jsont.json body with
19255 | Ok json -> Some (Openapi.Runtime.Json json)
19256 | Error _ -> Some (Openapi.Runtime.Raw body)
19257 in
19258 raise (Openapi.Runtime.Api_error {
19259 operation = op_name;
19260 method_ = "PUT";
19261 url;
19262 status = Requests.Response.status_code response;
19263 body;
19264 parsed_body;
19265 })
19266
19267 (** Retrieve assets by device ID
19268
19269 Get all asset of a device that are in the database, ID only. *)
19270 let get_all_user_assets_by_device_id ~device_id client () =
19271 let op_name = "get_all_user_assets_by_device_id" in
19272 let url_path = Openapi.Runtime.Path.render ~params:[("deviceId", device_id)] "/assets/device/{deviceId}" in
19273 let query = "" in
19274 let url = client.base_url ^ url_path ^ query in
19275 let response =
19276 try Requests.get client.session url
19277 with Eio.Io _ as ex ->
19278 let bt = Printexc.get_raw_backtrace () in
19279 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
19280 in
19281 if Requests.Response.ok response then
19282 Requests.Response.json response
19283 else
19284 let body = Requests.Response.text response in
19285 let parsed_body =
19286 match Jsont_bytesrw.decode_string Jsont.json body with
19287 | Ok json -> Some (Openapi.Runtime.Json json)
19288 | Error _ -> Some (Openapi.Runtime.Raw body)
19289 in
19290 raise (Openapi.Runtime.Api_error {
19291 operation = op_name;
19292 method_ = "GET";
19293 url;
19294 status = Requests.Response.status_code response;
19295 body;
19296 parsed_body;
19297 })
19298
19299 (** Run an asset job
19300
19301 Run a specific job on a set of assets. *)
19302 let run_asset_jobs ~body client () =
19303 let op_name = "run_asset_jobs" in
19304 let url_path = "/assets/jobs" in
19305 let query = "" in
19306 let url = client.base_url ^ url_path ^ query in
19307 let response =
19308 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetJobs.Dto.jsont body)) url
19309 with Eio.Io _ as ex ->
19310 let bt = Printexc.get_raw_backtrace () in
19311 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19312 in
19313 if Requests.Response.ok response then
19314 Requests.Response.json response
19315 else
19316 let body = Requests.Response.text response in
19317 let parsed_body =
19318 match Jsont_bytesrw.decode_string Jsont.json body with
19319 | Ok json -> Some (Openapi.Runtime.Json json)
19320 | Error _ -> Some (Openapi.Runtime.Raw body)
19321 in
19322 raise (Openapi.Runtime.Api_error {
19323 operation = op_name;
19324 method_ = "POST";
19325 url;
19326 status = Requests.Response.status_code response;
19327 body;
19328 parsed_body;
19329 })
19330
19331 (** Delete asset metadata
19332
19333 Delete metadata key-value pairs for multiple assets. *)
19334 let delete_bulk_asset_metadata client () =
19335 let op_name = "delete_bulk_asset_metadata" in
19336 let url_path = "/assets/metadata" in
19337 let query = "" in
19338 let url = client.base_url ^ url_path ^ query in
19339 let response =
19340 try Requests.delete client.session url
19341 with Eio.Io _ as ex ->
19342 let bt = Printexc.get_raw_backtrace () in
19343 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19344 in
19345 if Requests.Response.ok response then
19346 Requests.Response.json response
19347 else
19348 let body = Requests.Response.text response in
19349 let parsed_body =
19350 match Jsont_bytesrw.decode_string Jsont.json body with
19351 | Ok json -> Some (Openapi.Runtime.Json json)
19352 | Error _ -> Some (Openapi.Runtime.Raw body)
19353 in
19354 raise (Openapi.Runtime.Api_error {
19355 operation = op_name;
19356 method_ = "DELETE";
19357 url;
19358 status = Requests.Response.status_code response;
19359 body;
19360 parsed_body;
19361 })
19362
19363 (** Remove edits from an existing asset
19364
19365 Removes all edit actions (crop, rotate, mirror) associated with the specified asset. *)
19366 let remove_asset_edits ~id client () =
19367 let op_name = "remove_asset_edits" in
19368 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/edits" in
19369 let query = "" in
19370 let url = client.base_url ^ url_path ^ query in
19371 let response =
19372 try Requests.delete client.session url
19373 with Eio.Io _ as ex ->
19374 let bt = Printexc.get_raw_backtrace () in
19375 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19376 in
19377 if Requests.Response.ok response then
19378 Requests.Response.json response
19379 else
19380 let body = Requests.Response.text response in
19381 let parsed_body =
19382 match Jsont_bytesrw.decode_string Jsont.json body with
19383 | Ok json -> Some (Openapi.Runtime.Json json)
19384 | Error _ -> Some (Openapi.Runtime.Raw body)
19385 in
19386 raise (Openapi.Runtime.Api_error {
19387 operation = op_name;
19388 method_ = "DELETE";
19389 url;
19390 status = Requests.Response.status_code response;
19391 body;
19392 parsed_body;
19393 })
19394
19395 (** Delete asset metadata by key
19396
19397 Delete a specific metadata key-value pair associated with the specified asset. *)
19398 let delete_asset_metadata ~id ~key client () =
19399 let op_name = "delete_asset_metadata" in
19400 let url_path = Openapi.Runtime.Path.render ~params:[("id", id); ("key", key)] "/assets/{id}/metadata/{key}" in
19401 let query = "" in
19402 let url = client.base_url ^ url_path ^ query in
19403 let response =
19404 try Requests.delete client.session url
19405 with Eio.Io _ as ex ->
19406 let bt = Printexc.get_raw_backtrace () in
19407 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19408 in
19409 if Requests.Response.ok response then
19410 Requests.Response.json response
19411 else
19412 let body = Requests.Response.text response in
19413 let parsed_body =
19414 match Jsont_bytesrw.decode_string Jsont.json body with
19415 | Ok json -> Some (Openapi.Runtime.Json json)
19416 | Error _ -> Some (Openapi.Runtime.Raw body)
19417 in
19418 raise (Openapi.Runtime.Api_error {
19419 operation = op_name;
19420 method_ = "DELETE";
19421 url;
19422 status = Requests.Response.status_code response;
19423 body;
19424 parsed_body;
19425 })
19426
19427 (** Download original asset
19428
19429 Downloads the original file of the specified asset. *)
19430 let download_asset ~id ?edited ?key ?slug client () =
19431 let op_name = "download_asset" in
19432 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/original" in
19433 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"edited" ~value:edited; Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
19434 let url = client.base_url ^ url_path ^ query in
19435 let response =
19436 try Requests.get client.session url
19437 with Eio.Io _ as ex ->
19438 let bt = Printexc.get_raw_backtrace () in
19439 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
19440 in
19441 if Requests.Response.ok response then
19442 Requests.Response.json response
19443 else
19444 let body = Requests.Response.text response in
19445 let parsed_body =
19446 match Jsont_bytesrw.decode_string Jsont.json body with
19447 | Ok json -> Some (Openapi.Runtime.Json json)
19448 | Error _ -> Some (Openapi.Runtime.Raw body)
19449 in
19450 raise (Openapi.Runtime.Api_error {
19451 operation = op_name;
19452 method_ = "GET";
19453 url;
19454 status = Requests.Response.status_code response;
19455 body;
19456 parsed_body;
19457 })
19458
19459 (** View asset thumbnail
19460
19461 Retrieve the thumbnail image for the specified asset. Viewing the fullsize thumbnail might redirect to downloadAsset, which requires a different permission. *)
19462 let view_asset ~id ?edited ?key ?size ?slug client () =
19463 let op_name = "view_asset" in
19464 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/thumbnail" in
19465 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"edited" ~value:edited; Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"size" ~value:size; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
19466 let url = client.base_url ^ url_path ^ query in
19467 let response =
19468 try Requests.get client.session url
19469 with Eio.Io _ as ex ->
19470 let bt = Printexc.get_raw_backtrace () in
19471 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
19472 in
19473 if Requests.Response.ok response then
19474 Requests.Response.json response
19475 else
19476 let body = Requests.Response.text response in
19477 let parsed_body =
19478 match Jsont_bytesrw.decode_string Jsont.json body with
19479 | Ok json -> Some (Openapi.Runtime.Json json)
19480 | Error _ -> Some (Openapi.Runtime.Raw body)
19481 in
19482 raise (Openapi.Runtime.Api_error {
19483 operation = op_name;
19484 method_ = "GET";
19485 url;
19486 status = Requests.Response.status_code response;
19487 body;
19488 parsed_body;
19489 })
19490
19491 (** Play asset video
19492
19493 Streams the video file for the specified asset. This endpoint also supports byte range requests. *)
19494 let play_asset_video ~id ?key ?slug client () =
19495 let op_name = "play_asset_video" in
19496 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/assets/{id}/video/playback" in
19497 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
19498 let url = client.base_url ^ url_path ^ query in
19499 let response =
19500 try Requests.get client.session url
19501 with Eio.Io _ as ex ->
19502 let bt = Printexc.get_raw_backtrace () in
19503 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
19504 in
19505 if Requests.Response.ok response then
19506 Requests.Response.json response
19507 else
19508 let body = Requests.Response.text response in
19509 let parsed_body =
19510 match Jsont_bytesrw.decode_string Jsont.json body with
19511 | Ok json -> Some (Openapi.Runtime.Json json)
19512 | Error _ -> Some (Openapi.Runtime.Raw body)
19513 in
19514 raise (Openapi.Runtime.Api_error {
19515 operation = op_name;
19516 method_ = "GET";
19517 url;
19518 status = Requests.Response.status_code response;
19519 body;
19520 parsed_body;
19521 })
19522
19523 (** Setup pin code
19524
19525 Setup a new pin code for the current user. *)
19526 let setup_pin_code ~body client () =
19527 let op_name = "setup_pin_code" in
19528 let url_path = "/auth/pin-code" in
19529 let query = "" in
19530 let url = client.base_url ^ url_path ^ query in
19531 let response =
19532 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json PinCodeSetup.Dto.jsont body)) url
19533 with Eio.Io _ as ex ->
19534 let bt = Printexc.get_raw_backtrace () in
19535 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19536 in
19537 if Requests.Response.ok response then
19538 Requests.Response.json response
19539 else
19540 let body = Requests.Response.text response in
19541 let parsed_body =
19542 match Jsont_bytesrw.decode_string Jsont.json body with
19543 | Ok json -> Some (Openapi.Runtime.Json json)
19544 | Error _ -> Some (Openapi.Runtime.Raw body)
19545 in
19546 raise (Openapi.Runtime.Api_error {
19547 operation = op_name;
19548 method_ = "POST";
19549 url;
19550 status = Requests.Response.status_code response;
19551 body;
19552 parsed_body;
19553 })
19554
19555 (** Change pin code
19556
19557 Change the pin code for the current user. *)
19558 let change_pin_code ~body client () =
19559 let op_name = "change_pin_code" in
19560 let url_path = "/auth/pin-code" in
19561 let query = "" in
19562 let url = client.base_url ^ url_path ^ query in
19563 let response =
19564 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json PinCodeChange.Dto.jsont body)) url
19565 with Eio.Io _ as ex ->
19566 let bt = Printexc.get_raw_backtrace () in
19567 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
19568 in
19569 if Requests.Response.ok response then
19570 Requests.Response.json response
19571 else
19572 let body = Requests.Response.text response in
19573 let parsed_body =
19574 match Jsont_bytesrw.decode_string Jsont.json body with
19575 | Ok json -> Some (Openapi.Runtime.Json json)
19576 | Error _ -> Some (Openapi.Runtime.Raw body)
19577 in
19578 raise (Openapi.Runtime.Api_error {
19579 operation = op_name;
19580 method_ = "PUT";
19581 url;
19582 status = Requests.Response.status_code response;
19583 body;
19584 parsed_body;
19585 })
19586
19587 (** Reset pin code
19588
19589 Reset the pin code for the current user by providing the account password *)
19590 let reset_pin_code client () =
19591 let op_name = "reset_pin_code" in
19592 let url_path = "/auth/pin-code" in
19593 let query = "" in
19594 let url = client.base_url ^ url_path ^ query in
19595 let response =
19596 try Requests.delete client.session url
19597 with Eio.Io _ as ex ->
19598 let bt = Printexc.get_raw_backtrace () in
19599 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19600 in
19601 if Requests.Response.ok response then
19602 Requests.Response.json response
19603 else
19604 let body = Requests.Response.text response in
19605 let parsed_body =
19606 match Jsont_bytesrw.decode_string Jsont.json body with
19607 | Ok json -> Some (Openapi.Runtime.Json json)
19608 | Error _ -> Some (Openapi.Runtime.Raw body)
19609 in
19610 raise (Openapi.Runtime.Api_error {
19611 operation = op_name;
19612 method_ = "DELETE";
19613 url;
19614 status = Requests.Response.status_code response;
19615 body;
19616 parsed_body;
19617 })
19618
19619 (** Lock auth session
19620
19621 Remove elevated access to locked assets from the current session. *)
19622 let lock_auth_session client () =
19623 let op_name = "lock_auth_session" in
19624 let url_path = "/auth/session/lock" in
19625 let query = "" in
19626 let url = client.base_url ^ url_path ^ query in
19627 let response =
19628 try Requests.post client.session url
19629 with Eio.Io _ as ex ->
19630 let bt = Printexc.get_raw_backtrace () in
19631 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19632 in
19633 if Requests.Response.ok response then
19634 Requests.Response.json response
19635 else
19636 let body = Requests.Response.text response in
19637 let parsed_body =
19638 match Jsont_bytesrw.decode_string Jsont.json body with
19639 | Ok json -> Some (Openapi.Runtime.Json json)
19640 | Error _ -> Some (Openapi.Runtime.Raw body)
19641 in
19642 raise (Openapi.Runtime.Api_error {
19643 operation = op_name;
19644 method_ = "POST";
19645 url;
19646 status = Requests.Response.status_code response;
19647 body;
19648 parsed_body;
19649 })
19650
19651 (** Unlock auth session
19652
19653 Temporarily grant the session elevated access to locked assets by providing the correct PIN code. *)
19654 let unlock_auth_session ~body client () =
19655 let op_name = "unlock_auth_session" in
19656 let url_path = "/auth/session/unlock" in
19657 let query = "" in
19658 let url = client.base_url ^ url_path ^ query in
19659 let response =
19660 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SessionUnlock.Dto.jsont body)) url
19661 with Eio.Io _ as ex ->
19662 let bt = Printexc.get_raw_backtrace () in
19663 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19664 in
19665 if Requests.Response.ok response then
19666 Requests.Response.json response
19667 else
19668 let body = Requests.Response.text response in
19669 let parsed_body =
19670 match Jsont_bytesrw.decode_string Jsont.json body with
19671 | Ok json -> Some (Openapi.Runtime.Json json)
19672 | Error _ -> Some (Openapi.Runtime.Raw body)
19673 in
19674 raise (Openapi.Runtime.Api_error {
19675 operation = op_name;
19676 method_ = "POST";
19677 url;
19678 status = Requests.Response.status_code response;
19679 body;
19680 parsed_body;
19681 })
19682
19683 (** Download asset archive
19684
19685 Download a ZIP archive containing the specified assets. The assets must have been previously requested via the "getDownloadInfo" endpoint. *)
19686 let download_archive ?key ?slug ~body client () =
19687 let op_name = "download_archive" in
19688 let url_path = "/download/archive" in
19689 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"key" ~value:key; Openapi.Runtime.Query.optional ~key:"slug" ~value:slug]) in
19690 let url = client.base_url ^ url_path ^ query in
19691 let response =
19692 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetIds.Dto.jsont body)) url
19693 with Eio.Io _ as ex ->
19694 let bt = Printexc.get_raw_backtrace () in
19695 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19696 in
19697 if Requests.Response.ok response then
19698 Requests.Response.json response
19699 else
19700 let body = Requests.Response.text response in
19701 let parsed_body =
19702 match Jsont_bytesrw.decode_string Jsont.json body with
19703 | Ok json -> Some (Openapi.Runtime.Json json)
19704 | Error _ -> Some (Openapi.Runtime.Raw body)
19705 in
19706 raise (Openapi.Runtime.Api_error {
19707 operation = op_name;
19708 method_ = "POST";
19709 url;
19710 status = Requests.Response.status_code response;
19711 body;
19712 parsed_body;
19713 })
19714
19715 (** Delete duplicates
19716
19717 Delete multiple duplicate assets specified by their IDs. *)
19718 let delete_duplicates client () =
19719 let op_name = "delete_duplicates" in
19720 let url_path = "/duplicates" in
19721 let query = "" in
19722 let url = client.base_url ^ url_path ^ query in
19723 let response =
19724 try Requests.delete client.session url
19725 with Eio.Io _ as ex ->
19726 let bt = Printexc.get_raw_backtrace () in
19727 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19728 in
19729 if Requests.Response.ok response then
19730 Requests.Response.json response
19731 else
19732 let body = Requests.Response.text response in
19733 let parsed_body =
19734 match Jsont_bytesrw.decode_string Jsont.json body with
19735 | Ok json -> Some (Openapi.Runtime.Json json)
19736 | Error _ -> Some (Openapi.Runtime.Raw body)
19737 in
19738 raise (Openapi.Runtime.Api_error {
19739 operation = op_name;
19740 method_ = "DELETE";
19741 url;
19742 status = Requests.Response.status_code response;
19743 body;
19744 parsed_body;
19745 })
19746
19747 (** Delete a duplicate
19748
19749 Delete a single duplicate asset specified by its ID. *)
19750 let delete_duplicate ~id client () =
19751 let op_name = "delete_duplicate" in
19752 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/duplicates/{id}" in
19753 let query = "" in
19754 let url = client.base_url ^ url_path ^ query in
19755 let response =
19756 try Requests.delete client.session url
19757 with Eio.Io _ as ex ->
19758 let bt = Printexc.get_raw_backtrace () in
19759 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19760 in
19761 if Requests.Response.ok response then
19762 Requests.Response.json response
19763 else
19764 let body = Requests.Response.text response in
19765 let parsed_body =
19766 match Jsont_bytesrw.decode_string Jsont.json body with
19767 | Ok json -> Some (Openapi.Runtime.Json json)
19768 | Error _ -> Some (Openapi.Runtime.Raw body)
19769 in
19770 raise (Openapi.Runtime.Api_error {
19771 operation = op_name;
19772 method_ = "DELETE";
19773 url;
19774 status = Requests.Response.status_code response;
19775 body;
19776 parsed_body;
19777 })
19778
19779 (** Create a face
19780
19781 Create a new face that has not been discovered by facial recognition. The content of the bounding box is considered a face. *)
19782 let create_face ~body client () =
19783 let op_name = "create_face" in
19784 let url_path = "/faces" in
19785 let query = "" in
19786 let url = client.base_url ^ url_path ^ query in
19787 let response =
19788 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AssetFace.CreateDto.jsont body)) url
19789 with Eio.Io _ as ex ->
19790 let bt = Printexc.get_raw_backtrace () in
19791 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19792 in
19793 if Requests.Response.ok response then
19794 Requests.Response.json response
19795 else
19796 let body = Requests.Response.text response in
19797 let parsed_body =
19798 match Jsont_bytesrw.decode_string Jsont.json body with
19799 | Ok json -> Some (Openapi.Runtime.Json json)
19800 | Error _ -> Some (Openapi.Runtime.Raw body)
19801 in
19802 raise (Openapi.Runtime.Api_error {
19803 operation = op_name;
19804 method_ = "POST";
19805 url;
19806 status = Requests.Response.status_code response;
19807 body;
19808 parsed_body;
19809 })
19810
19811 (** Delete a face
19812
19813 Delete a face identified by the id. Optionally can be force deleted. *)
19814 let delete_face ~id client () =
19815 let op_name = "delete_face" in
19816 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/faces/{id}" in
19817 let query = "" in
19818 let url = client.base_url ^ url_path ^ query in
19819 let response =
19820 try Requests.delete client.session url
19821 with Eio.Io _ as ex ->
19822 let bt = Printexc.get_raw_backtrace () in
19823 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19824 in
19825 if Requests.Response.ok response then
19826 Requests.Response.json response
19827 else
19828 let body = Requests.Response.text response in
19829 let parsed_body =
19830 match Jsont_bytesrw.decode_string Jsont.json body with
19831 | Ok json -> Some (Openapi.Runtime.Json json)
19832 | Error _ -> Some (Openapi.Runtime.Raw body)
19833 in
19834 raise (Openapi.Runtime.Api_error {
19835 operation = op_name;
19836 method_ = "DELETE";
19837 url;
19838 status = Requests.Response.status_code response;
19839 body;
19840 parsed_body;
19841 })
19842
19843 (** Create a manual job
19844
19845 Run a specific job. Most jobs are queued automatically, but this endpoint allows for manual creation of a handful of jobs, including various cleanup tasks, as well as creating a new database backup. *)
19846 let create_job ~body client () =
19847 let op_name = "create_job" in
19848 let url_path = "/jobs" in
19849 let query = "" in
19850 let url = client.base_url ^ url_path ^ query in
19851 let response =
19852 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json Job.CreateDto.jsont body)) url
19853 with Eio.Io _ as ex ->
19854 let bt = Printexc.get_raw_backtrace () in
19855 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19856 in
19857 if Requests.Response.ok response then
19858 Requests.Response.json response
19859 else
19860 let body = Requests.Response.text response in
19861 let parsed_body =
19862 match Jsont_bytesrw.decode_string Jsont.json body with
19863 | Ok json -> Some (Openapi.Runtime.Json json)
19864 | Error _ -> Some (Openapi.Runtime.Raw body)
19865 in
19866 raise (Openapi.Runtime.Api_error {
19867 operation = op_name;
19868 method_ = "POST";
19869 url;
19870 status = Requests.Response.status_code response;
19871 body;
19872 parsed_body;
19873 })
19874
19875 (** Delete a library
19876
19877 Delete an external library by its ID. *)
19878 let delete_library ~id client () =
19879 let op_name = "delete_library" in
19880 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}" in
19881 let query = "" in
19882 let url = client.base_url ^ url_path ^ query in
19883 let response =
19884 try Requests.delete client.session url
19885 with Eio.Io _ as ex ->
19886 let bt = Printexc.get_raw_backtrace () in
19887 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19888 in
19889 if Requests.Response.ok response then
19890 Requests.Response.json response
19891 else
19892 let body = Requests.Response.text response in
19893 let parsed_body =
19894 match Jsont_bytesrw.decode_string Jsont.json body with
19895 | Ok json -> Some (Openapi.Runtime.Json json)
19896 | Error _ -> Some (Openapi.Runtime.Raw body)
19897 in
19898 raise (Openapi.Runtime.Api_error {
19899 operation = op_name;
19900 method_ = "DELETE";
19901 url;
19902 status = Requests.Response.status_code response;
19903 body;
19904 parsed_body;
19905 })
19906
19907 (** Scan a library
19908
19909 Queue a scan for the external library to find and import new assets. *)
19910 let scan_library ~id client () =
19911 let op_name = "scan_library" in
19912 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/libraries/{id}/scan" in
19913 let query = "" in
19914 let url = client.base_url ^ url_path ^ query in
19915 let response =
19916 try Requests.post client.session url
19917 with Eio.Io _ as ex ->
19918 let bt = Printexc.get_raw_backtrace () in
19919 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
19920 in
19921 if Requests.Response.ok response then
19922 Requests.Response.json response
19923 else
19924 let body = Requests.Response.text response in
19925 let parsed_body =
19926 match Jsont_bytesrw.decode_string Jsont.json body with
19927 | Ok json -> Some (Openapi.Runtime.Json json)
19928 | Error _ -> Some (Openapi.Runtime.Raw body)
19929 in
19930 raise (Openapi.Runtime.Api_error {
19931 operation = op_name;
19932 method_ = "POST";
19933 url;
19934 status = Requests.Response.status_code response;
19935 body;
19936 parsed_body;
19937 })
19938
19939 (** Delete a memory
19940
19941 Delete a specific memory by its ID. *)
19942 let delete_memory ~id client () =
19943 let op_name = "delete_memory" in
19944 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/memories/{id}" in
19945 let query = "" in
19946 let url = client.base_url ^ url_path ^ query in
19947 let response =
19948 try Requests.delete client.session url
19949 with Eio.Io _ as ex ->
19950 let bt = Printexc.get_raw_backtrace () in
19951 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
19952 in
19953 if Requests.Response.ok response then
19954 Requests.Response.json response
19955 else
19956 let body = Requests.Response.text response in
19957 let parsed_body =
19958 match Jsont_bytesrw.decode_string Jsont.json body with
19959 | Ok json -> Some (Openapi.Runtime.Json json)
19960 | Error _ -> Some (Openapi.Runtime.Raw body)
19961 in
19962 raise (Openapi.Runtime.Api_error {
19963 operation = op_name;
19964 method_ = "DELETE";
19965 url;
19966 status = Requests.Response.status_code response;
19967 body;
19968 parsed_body;
19969 })
19970
19971 (** Update notifications
19972
19973 Update a list of notifications. Allows to bulk-set the read status of notifications. *)
19974 let update_notifications ~body client () =
19975 let op_name = "update_notifications" in
19976 let url_path = "/notifications" in
19977 let query = "" in
19978 let url = client.base_url ^ url_path ^ query in
19979 let response =
19980 try Requests.put client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json NotificationUpdateAll.Dto.jsont body)) url
19981 with Eio.Io _ as ex ->
19982 let bt = Printexc.get_raw_backtrace () in
19983 Eio.Exn.reraise_with_context ex bt "calling %s %s" "PUT" url
19984 in
19985 if Requests.Response.ok response then
19986 Requests.Response.json response
19987 else
19988 let body = Requests.Response.text response in
19989 let parsed_body =
19990 match Jsont_bytesrw.decode_string Jsont.json body with
19991 | Ok json -> Some (Openapi.Runtime.Json json)
19992 | Error _ -> Some (Openapi.Runtime.Raw body)
19993 in
19994 raise (Openapi.Runtime.Api_error {
19995 operation = op_name;
19996 method_ = "PUT";
19997 url;
19998 status = Requests.Response.status_code response;
19999 body;
20000 parsed_body;
20001 })
20002
20003 (** Delete notifications
20004
20005 Delete a list of notifications at once. *)
20006 let delete_notifications client () =
20007 let op_name = "delete_notifications" in
20008 let url_path = "/notifications" in
20009 let query = "" in
20010 let url = client.base_url ^ url_path ^ query in
20011 let response =
20012 try Requests.delete client.session url
20013 with Eio.Io _ as ex ->
20014 let bt = Printexc.get_raw_backtrace () in
20015 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20016 in
20017 if Requests.Response.ok response then
20018 Requests.Response.json response
20019 else
20020 let body = Requests.Response.text response in
20021 let parsed_body =
20022 match Jsont_bytesrw.decode_string Jsont.json body with
20023 | Ok json -> Some (Openapi.Runtime.Json json)
20024 | Error _ -> Some (Openapi.Runtime.Raw body)
20025 in
20026 raise (Openapi.Runtime.Api_error {
20027 operation = op_name;
20028 method_ = "DELETE";
20029 url;
20030 status = Requests.Response.status_code response;
20031 body;
20032 parsed_body;
20033 })
20034
20035 (** Delete a notification
20036
20037 Delete a specific notification. *)
20038 let delete_notification ~id client () =
20039 let op_name = "delete_notification" in
20040 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/notifications/{id}" in
20041 let query = "" in
20042 let url = client.base_url ^ url_path ^ query in
20043 let response =
20044 try Requests.delete client.session url
20045 with Eio.Io _ as ex ->
20046 let bt = Printexc.get_raw_backtrace () in
20047 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20048 in
20049 if Requests.Response.ok response then
20050 Requests.Response.json response
20051 else
20052 let body = Requests.Response.text response in
20053 let parsed_body =
20054 match Jsont_bytesrw.decode_string Jsont.json body with
20055 | Ok json -> Some (Openapi.Runtime.Json json)
20056 | Error _ -> Some (Openapi.Runtime.Raw body)
20057 in
20058 raise (Openapi.Runtime.Api_error {
20059 operation = op_name;
20060 method_ = "DELETE";
20061 url;
20062 status = Requests.Response.status_code response;
20063 body;
20064 parsed_body;
20065 })
20066
20067 (** Redirect OAuth to mobile
20068
20069 Requests to this URL are automatically forwarded to the mobile app, and is used in some cases for OAuth redirecting. *)
20070 let redirect_oauth_to_mobile client () =
20071 let op_name = "redirect_oauth_to_mobile" in
20072 let url_path = "/oauth/mobile-redirect" in
20073 let query = "" in
20074 let url = client.base_url ^ url_path ^ query in
20075 let response =
20076 try Requests.get client.session url
20077 with Eio.Io _ as ex ->
20078 let bt = Printexc.get_raw_backtrace () in
20079 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
20080 in
20081 if Requests.Response.ok response then
20082 Requests.Response.json response
20083 else
20084 let body = Requests.Response.text response in
20085 let parsed_body =
20086 match Jsont_bytesrw.decode_string Jsont.json body with
20087 | Ok json -> Some (Openapi.Runtime.Json json)
20088 | Error _ -> Some (Openapi.Runtime.Raw body)
20089 in
20090 raise (Openapi.Runtime.Api_error {
20091 operation = op_name;
20092 method_ = "GET";
20093 url;
20094 status = Requests.Response.status_code response;
20095 body;
20096 parsed_body;
20097 })
20098
20099 (** Remove a partner
20100
20101 Stop sharing assets with a partner. *)
20102 let remove_partner ~id client () =
20103 let op_name = "remove_partner" in
20104 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/partners/{id}" in
20105 let query = "" in
20106 let url = client.base_url ^ url_path ^ query in
20107 let response =
20108 try Requests.delete client.session url
20109 with Eio.Io _ as ex ->
20110 let bt = Printexc.get_raw_backtrace () in
20111 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20112 in
20113 if Requests.Response.ok response then
20114 Requests.Response.json response
20115 else
20116 let body = Requests.Response.text response in
20117 let parsed_body =
20118 match Jsont_bytesrw.decode_string Jsont.json body with
20119 | Ok json -> Some (Openapi.Runtime.Json json)
20120 | Error _ -> Some (Openapi.Runtime.Raw body)
20121 in
20122 raise (Openapi.Runtime.Api_error {
20123 operation = op_name;
20124 method_ = "DELETE";
20125 url;
20126 status = Requests.Response.status_code response;
20127 body;
20128 parsed_body;
20129 })
20130
20131 (** Delete people
20132
20133 Bulk delete a list of people at once. *)
20134 let delete_people client () =
20135 let op_name = "delete_people" in
20136 let url_path = "/people" in
20137 let query = "" in
20138 let url = client.base_url ^ url_path ^ query in
20139 let response =
20140 try Requests.delete client.session url
20141 with Eio.Io _ as ex ->
20142 let bt = Printexc.get_raw_backtrace () in
20143 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20144 in
20145 if Requests.Response.ok response then
20146 Requests.Response.json response
20147 else
20148 let body = Requests.Response.text response in
20149 let parsed_body =
20150 match Jsont_bytesrw.decode_string Jsont.json body with
20151 | Ok json -> Some (Openapi.Runtime.Json json)
20152 | Error _ -> Some (Openapi.Runtime.Raw body)
20153 in
20154 raise (Openapi.Runtime.Api_error {
20155 operation = op_name;
20156 method_ = "DELETE";
20157 url;
20158 status = Requests.Response.status_code response;
20159 body;
20160 parsed_body;
20161 })
20162
20163 (** Delete person
20164
20165 Delete an individual person. *)
20166 let delete_person ~id client () =
20167 let op_name = "delete_person" in
20168 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}" in
20169 let query = "" in
20170 let url = client.base_url ^ url_path ^ query in
20171 let response =
20172 try Requests.delete client.session url
20173 with Eio.Io _ as ex ->
20174 let bt = Printexc.get_raw_backtrace () in
20175 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20176 in
20177 if Requests.Response.ok response then
20178 Requests.Response.json response
20179 else
20180 let body = Requests.Response.text response in
20181 let parsed_body =
20182 match Jsont_bytesrw.decode_string Jsont.json body with
20183 | Ok json -> Some (Openapi.Runtime.Json json)
20184 | Error _ -> Some (Openapi.Runtime.Raw body)
20185 in
20186 raise (Openapi.Runtime.Api_error {
20187 operation = op_name;
20188 method_ = "DELETE";
20189 url;
20190 status = Requests.Response.status_code response;
20191 body;
20192 parsed_body;
20193 })
20194
20195 (** Get person thumbnail
20196
20197 Retrieve the thumbnail file for a person. *)
20198 let get_person_thumbnail ~id client () =
20199 let op_name = "get_person_thumbnail" in
20200 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/people/{id}/thumbnail" in
20201 let query = "" in
20202 let url = client.base_url ^ url_path ^ query in
20203 let response =
20204 try Requests.get client.session url
20205 with Eio.Io _ as ex ->
20206 let bt = Printexc.get_raw_backtrace () in
20207 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
20208 in
20209 if Requests.Response.ok response then
20210 Requests.Response.json response
20211 else
20212 let body = Requests.Response.text response in
20213 let parsed_body =
20214 match Jsont_bytesrw.decode_string Jsont.json body with
20215 | Ok json -> Some (Openapi.Runtime.Json json)
20216 | Error _ -> Some (Openapi.Runtime.Raw body)
20217 in
20218 raise (Openapi.Runtime.Api_error {
20219 operation = op_name;
20220 method_ = "GET";
20221 url;
20222 status = Requests.Response.status_code response;
20223 body;
20224 parsed_body;
20225 })
20226
20227 (** Empty a queue
20228
20229 Removes all jobs from the specified queue. *)
20230 let empty_queue ~name client () =
20231 let op_name = "empty_queue" in
20232 let url_path = Openapi.Runtime.Path.render ~params:[("name", name)] "/queues/{name}/jobs" in
20233 let query = "" in
20234 let url = client.base_url ^ url_path ^ query in
20235 let response =
20236 try Requests.delete client.session url
20237 with Eio.Io _ as ex ->
20238 let bt = Printexc.get_raw_backtrace () in
20239 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20240 in
20241 if Requests.Response.ok response then
20242 Requests.Response.json response
20243 else
20244 let body = Requests.Response.text response in
20245 let parsed_body =
20246 match Jsont_bytesrw.decode_string Jsont.json body with
20247 | Ok json -> Some (Openapi.Runtime.Json json)
20248 | Error _ -> Some (Openapi.Runtime.Raw body)
20249 in
20250 raise (Openapi.Runtime.Api_error {
20251 operation = op_name;
20252 method_ = "DELETE";
20253 url;
20254 status = Requests.Response.status_code response;
20255 body;
20256 parsed_body;
20257 })
20258
20259 (** Retrieve search suggestions
20260
20261 Retrieve search suggestions based on partial input. This endpoint is used for typeahead search features. *)
20262 let get_search_suggestions ?country ?include_null ?lens_model ?make ?model ?state ~type_ client () =
20263 let op_name = "get_search_suggestions" in
20264 let url_path = "/search/suggestions" in
20265 let query = Openapi.Runtime.Query.encode (List.concat [Openapi.Runtime.Query.optional ~key:"country" ~value:country; Openapi.Runtime.Query.optional ~key:"includeNull" ~value:include_null; Openapi.Runtime.Query.optional ~key:"lensModel" ~value:lens_model; Openapi.Runtime.Query.optional ~key:"make" ~value:make; Openapi.Runtime.Query.optional ~key:"model" ~value:model; Openapi.Runtime.Query.optional ~key:"state" ~value:state; Openapi.Runtime.Query.singleton ~key:"type" ~value:type_]) in
20266 let url = client.base_url ^ url_path ^ query in
20267 let response =
20268 try Requests.get client.session url
20269 with Eio.Io _ as ex ->
20270 let bt = Printexc.get_raw_backtrace () in
20271 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
20272 in
20273 if Requests.Response.ok response then
20274 Requests.Response.json response
20275 else
20276 let body = Requests.Response.text response in
20277 let parsed_body =
20278 match Jsont_bytesrw.decode_string Jsont.json body with
20279 | Ok json -> Some (Openapi.Runtime.Json json)
20280 | Error _ -> Some (Openapi.Runtime.Raw body)
20281 in
20282 raise (Openapi.Runtime.Api_error {
20283 operation = op_name;
20284 method_ = "GET";
20285 url;
20286 status = Requests.Response.status_code response;
20287 body;
20288 parsed_body;
20289 })
20290
20291 (** Delete server product key
20292
20293 Delete the currently set server product key. *)
20294 let delete_server_license client () =
20295 let op_name = "delete_server_license" in
20296 let url_path = "/server/license" in
20297 let query = "" in
20298 let url = client.base_url ^ url_path ^ query in
20299 let response =
20300 try Requests.delete client.session url
20301 with Eio.Io _ as ex ->
20302 let bt = Printexc.get_raw_backtrace () in
20303 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20304 in
20305 if Requests.Response.ok response then
20306 Requests.Response.json response
20307 else
20308 let body = Requests.Response.text response in
20309 let parsed_body =
20310 match Jsont_bytesrw.decode_string Jsont.json body with
20311 | Ok json -> Some (Openapi.Runtime.Json json)
20312 | Error _ -> Some (Openapi.Runtime.Raw body)
20313 in
20314 raise (Openapi.Runtime.Api_error {
20315 operation = op_name;
20316 method_ = "DELETE";
20317 url;
20318 status = Requests.Response.status_code response;
20319 body;
20320 parsed_body;
20321 })
20322
20323 (** Delete all sessions
20324
20325 Delete all sessions for the user. This will not delete the current session. *)
20326 let delete_all_sessions client () =
20327 let op_name = "delete_all_sessions" in
20328 let url_path = "/sessions" in
20329 let query = "" in
20330 let url = client.base_url ^ url_path ^ query in
20331 let response =
20332 try Requests.delete client.session url
20333 with Eio.Io _ as ex ->
20334 let bt = Printexc.get_raw_backtrace () in
20335 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20336 in
20337 if Requests.Response.ok response then
20338 Requests.Response.json response
20339 else
20340 let body = Requests.Response.text response in
20341 let parsed_body =
20342 match Jsont_bytesrw.decode_string Jsont.json body with
20343 | Ok json -> Some (Openapi.Runtime.Json json)
20344 | Error _ -> Some (Openapi.Runtime.Raw body)
20345 in
20346 raise (Openapi.Runtime.Api_error {
20347 operation = op_name;
20348 method_ = "DELETE";
20349 url;
20350 status = Requests.Response.status_code response;
20351 body;
20352 parsed_body;
20353 })
20354
20355 (** Delete a session
20356
20357 Delete a specific session by id. *)
20358 let delete_session ~id client () =
20359 let op_name = "delete_session" in
20360 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/sessions/{id}" in
20361 let query = "" in
20362 let url = client.base_url ^ url_path ^ query in
20363 let response =
20364 try Requests.delete client.session url
20365 with Eio.Io _ as ex ->
20366 let bt = Printexc.get_raw_backtrace () in
20367 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20368 in
20369 if Requests.Response.ok response then
20370 Requests.Response.json response
20371 else
20372 let body = Requests.Response.text response in
20373 let parsed_body =
20374 match Jsont_bytesrw.decode_string Jsont.json body with
20375 | Ok json -> Some (Openapi.Runtime.Json json)
20376 | Error _ -> Some (Openapi.Runtime.Raw body)
20377 in
20378 raise (Openapi.Runtime.Api_error {
20379 operation = op_name;
20380 method_ = "DELETE";
20381 url;
20382 status = Requests.Response.status_code response;
20383 body;
20384 parsed_body;
20385 })
20386
20387 (** Lock a session
20388
20389 Lock a specific session by id. *)
20390 let lock_session ~id client () =
20391 let op_name = "lock_session" in
20392 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/sessions/{id}/lock" in
20393 let query = "" in
20394 let url = client.base_url ^ url_path ^ query in
20395 let response =
20396 try Requests.post client.session url
20397 with Eio.Io _ as ex ->
20398 let bt = Printexc.get_raw_backtrace () in
20399 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
20400 in
20401 if Requests.Response.ok response then
20402 Requests.Response.json response
20403 else
20404 let body = Requests.Response.text response in
20405 let parsed_body =
20406 match Jsont_bytesrw.decode_string Jsont.json body with
20407 | Ok json -> Some (Openapi.Runtime.Json json)
20408 | Error _ -> Some (Openapi.Runtime.Raw body)
20409 in
20410 raise (Openapi.Runtime.Api_error {
20411 operation = op_name;
20412 method_ = "POST";
20413 url;
20414 status = Requests.Response.status_code response;
20415 body;
20416 parsed_body;
20417 })
20418
20419 (** Delete a shared link
20420
20421 Delete a specific shared link by its ID. *)
20422 let remove_shared_link ~id client () =
20423 let op_name = "remove_shared_link" in
20424 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/shared-links/{id}" in
20425 let query = "" in
20426 let url = client.base_url ^ url_path ^ query in
20427 let response =
20428 try Requests.delete client.session url
20429 with Eio.Io _ as ex ->
20430 let bt = Printexc.get_raw_backtrace () in
20431 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20432 in
20433 if Requests.Response.ok response then
20434 Requests.Response.json response
20435 else
20436 let body = Requests.Response.text response in
20437 let parsed_body =
20438 match Jsont_bytesrw.decode_string Jsont.json body with
20439 | Ok json -> Some (Openapi.Runtime.Json json)
20440 | Error _ -> Some (Openapi.Runtime.Raw body)
20441 in
20442 raise (Openapi.Runtime.Api_error {
20443 operation = op_name;
20444 method_ = "DELETE";
20445 url;
20446 status = Requests.Response.status_code response;
20447 body;
20448 parsed_body;
20449 })
20450
20451 (** Delete stacks
20452
20453 Delete multiple stacks by providing a list of stack IDs. *)
20454 let delete_stacks client () =
20455 let op_name = "delete_stacks" in
20456 let url_path = "/stacks" in
20457 let query = "" in
20458 let url = client.base_url ^ url_path ^ query in
20459 let response =
20460 try Requests.delete client.session url
20461 with Eio.Io _ as ex ->
20462 let bt = Printexc.get_raw_backtrace () in
20463 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20464 in
20465 if Requests.Response.ok response then
20466 Requests.Response.json response
20467 else
20468 let body = Requests.Response.text response in
20469 let parsed_body =
20470 match Jsont_bytesrw.decode_string Jsont.json body with
20471 | Ok json -> Some (Openapi.Runtime.Json json)
20472 | Error _ -> Some (Openapi.Runtime.Raw body)
20473 in
20474 raise (Openapi.Runtime.Api_error {
20475 operation = op_name;
20476 method_ = "DELETE";
20477 url;
20478 status = Requests.Response.status_code response;
20479 body;
20480 parsed_body;
20481 })
20482
20483 (** Delete a stack
20484
20485 Delete a specific stack by its ID. *)
20486 let delete_stack ~id client () =
20487 let op_name = "delete_stack" in
20488 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/stacks/{id}" in
20489 let query = "" in
20490 let url = client.base_url ^ url_path ^ query in
20491 let response =
20492 try Requests.delete client.session url
20493 with Eio.Io _ as ex ->
20494 let bt = Printexc.get_raw_backtrace () in
20495 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20496 in
20497 if Requests.Response.ok response then
20498 Requests.Response.json response
20499 else
20500 let body = Requests.Response.text response in
20501 let parsed_body =
20502 match Jsont_bytesrw.decode_string Jsont.json body with
20503 | Ok json -> Some (Openapi.Runtime.Json json)
20504 | Error _ -> Some (Openapi.Runtime.Raw body)
20505 in
20506 raise (Openapi.Runtime.Api_error {
20507 operation = op_name;
20508 method_ = "DELETE";
20509 url;
20510 status = Requests.Response.status_code response;
20511 body;
20512 parsed_body;
20513 })
20514
20515 (** Remove an asset from a stack
20516
20517 Remove a specific asset from a stack by providing the stack ID and asset ID. *)
20518 let remove_asset_from_stack ~asset_id ~id client () =
20519 let op_name = "remove_asset_from_stack" in
20520 let url_path = Openapi.Runtime.Path.render ~params:[("assetId", asset_id); ("id", id)] "/stacks/{id}/assets/{assetId}" in
20521 let query = "" in
20522 let url = client.base_url ^ url_path ^ query in
20523 let response =
20524 try Requests.delete client.session url
20525 with Eio.Io _ as ex ->
20526 let bt = Printexc.get_raw_backtrace () in
20527 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20528 in
20529 if Requests.Response.ok response then
20530 Requests.Response.json response
20531 else
20532 let body = Requests.Response.text response in
20533 let parsed_body =
20534 match Jsont_bytesrw.decode_string Jsont.json body with
20535 | Ok json -> Some (Openapi.Runtime.Json json)
20536 | Error _ -> Some (Openapi.Runtime.Raw body)
20537 in
20538 raise (Openapi.Runtime.Api_error {
20539 operation = op_name;
20540 method_ = "DELETE";
20541 url;
20542 status = Requests.Response.status_code response;
20543 body;
20544 parsed_body;
20545 })
20546
20547 (** Acknowledge changes
20548
20549 Send a list of synchronization acknowledgements to confirm that the latest changes have been received. *)
20550 let send_sync_ack ~body client () =
20551 let op_name = "send_sync_ack" in
20552 let url_path = "/sync/ack" in
20553 let query = "" in
20554 let url = client.base_url ^ url_path ^ query in
20555 let response =
20556 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SyncAckSet.Dto.jsont body)) url
20557 with Eio.Io _ as ex ->
20558 let bt = Printexc.get_raw_backtrace () in
20559 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
20560 in
20561 if Requests.Response.ok response then
20562 Requests.Response.json response
20563 else
20564 let body = Requests.Response.text response in
20565 let parsed_body =
20566 match Jsont_bytesrw.decode_string Jsont.json body with
20567 | Ok json -> Some (Openapi.Runtime.Json json)
20568 | Error _ -> Some (Openapi.Runtime.Raw body)
20569 in
20570 raise (Openapi.Runtime.Api_error {
20571 operation = op_name;
20572 method_ = "POST";
20573 url;
20574 status = Requests.Response.status_code response;
20575 body;
20576 parsed_body;
20577 })
20578
20579 (** Delete acknowledgements
20580
20581 Delete specific synchronization acknowledgments. *)
20582 let delete_sync_ack client () =
20583 let op_name = "delete_sync_ack" in
20584 let url_path = "/sync/ack" in
20585 let query = "" in
20586 let url = client.base_url ^ url_path ^ query in
20587 let response =
20588 try Requests.delete client.session url
20589 with Eio.Io _ as ex ->
20590 let bt = Printexc.get_raw_backtrace () in
20591 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20592 in
20593 if Requests.Response.ok response then
20594 Requests.Response.json response
20595 else
20596 let body = Requests.Response.text response in
20597 let parsed_body =
20598 match Jsont_bytesrw.decode_string Jsont.json body with
20599 | Ok json -> Some (Openapi.Runtime.Json json)
20600 | Error _ -> Some (Openapi.Runtime.Raw body)
20601 in
20602 raise (Openapi.Runtime.Api_error {
20603 operation = op_name;
20604 method_ = "DELETE";
20605 url;
20606 status = Requests.Response.status_code response;
20607 body;
20608 parsed_body;
20609 })
20610
20611 (** Stream sync changes
20612
20613 Retrieve a JSON lines streamed response of changes for synchronization. This endpoint is used by the mobile app to efficiently stay up to date with changes. *)
20614 let get_sync_stream ~body client () =
20615 let op_name = "get_sync_stream" in
20616 let url_path = "/sync/stream" in
20617 let query = "" in
20618 let url = client.base_url ^ url_path ^ query in
20619 let response =
20620 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json SyncStream.Dto.jsont body)) url
20621 with Eio.Io _ as ex ->
20622 let bt = Printexc.get_raw_backtrace () in
20623 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
20624 in
20625 if Requests.Response.ok response then
20626 Requests.Response.json response
20627 else
20628 let body = Requests.Response.text response in
20629 let parsed_body =
20630 match Jsont_bytesrw.decode_string Jsont.json body with
20631 | Ok json -> Some (Openapi.Runtime.Json json)
20632 | Error _ -> Some (Openapi.Runtime.Raw body)
20633 in
20634 raise (Openapi.Runtime.Api_error {
20635 operation = op_name;
20636 method_ = "POST";
20637 url;
20638 status = Requests.Response.status_code response;
20639 body;
20640 parsed_body;
20641 })
20642
20643 (** Update admin onboarding
20644
20645 Update the admin onboarding status. *)
20646 let update_admin_onboarding ~body client () =
20647 let op_name = "update_admin_onboarding" in
20648 let url_path = "/system-metadata/admin-onboarding" in
20649 let query = "" in
20650 let url = client.base_url ^ url_path ^ query in
20651 let response =
20652 try Requests.post client.session ~body:(Requests.Body.json (Openapi.Runtime.Json.encode_json AdminOnboarding.UpdateDto.jsont body)) url
20653 with Eio.Io _ as ex ->
20654 let bt = Printexc.get_raw_backtrace () in
20655 Eio.Exn.reraise_with_context ex bt "calling %s %s" "POST" url
20656 in
20657 if Requests.Response.ok response then
20658 Requests.Response.json response
20659 else
20660 let body = Requests.Response.text response in
20661 let parsed_body =
20662 match Jsont_bytesrw.decode_string Jsont.json body with
20663 | Ok json -> Some (Openapi.Runtime.Json json)
20664 | Error _ -> Some (Openapi.Runtime.Raw body)
20665 in
20666 raise (Openapi.Runtime.Api_error {
20667 operation = op_name;
20668 method_ = "POST";
20669 url;
20670 status = Requests.Response.status_code response;
20671 body;
20672 parsed_body;
20673 })
20674
20675 (** Delete a tag
20676
20677 Delete a specific tag by its ID. *)
20678 let delete_tag ~id client () =
20679 let op_name = "delete_tag" in
20680 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/tags/{id}" in
20681 let query = "" in
20682 let url = client.base_url ^ url_path ^ query in
20683 let response =
20684 try Requests.delete client.session url
20685 with Eio.Io _ as ex ->
20686 let bt = Printexc.get_raw_backtrace () in
20687 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20688 in
20689 if Requests.Response.ok response then
20690 Requests.Response.json response
20691 else
20692 let body = Requests.Response.text response in
20693 let parsed_body =
20694 match Jsont_bytesrw.decode_string Jsont.json body with
20695 | Ok json -> Some (Openapi.Runtime.Json json)
20696 | Error _ -> Some (Openapi.Runtime.Raw body)
20697 in
20698 raise (Openapi.Runtime.Api_error {
20699 operation = op_name;
20700 method_ = "DELETE";
20701 url;
20702 status = Requests.Response.status_code response;
20703 body;
20704 parsed_body;
20705 })
20706
20707 (** Delete user product key
20708
20709 Delete the registered product key for the current user. *)
20710 let delete_user_license client () =
20711 let op_name = "delete_user_license" in
20712 let url_path = "/users/me/license" in
20713 let query = "" in
20714 let url = client.base_url ^ url_path ^ query in
20715 let response =
20716 try Requests.delete client.session url
20717 with Eio.Io _ as ex ->
20718 let bt = Printexc.get_raw_backtrace () in
20719 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20720 in
20721 if Requests.Response.ok response then
20722 Requests.Response.json response
20723 else
20724 let body = Requests.Response.text response in
20725 let parsed_body =
20726 match Jsont_bytesrw.decode_string Jsont.json body with
20727 | Ok json -> Some (Openapi.Runtime.Json json)
20728 | Error _ -> Some (Openapi.Runtime.Raw body)
20729 in
20730 raise (Openapi.Runtime.Api_error {
20731 operation = op_name;
20732 method_ = "DELETE";
20733 url;
20734 status = Requests.Response.status_code response;
20735 body;
20736 parsed_body;
20737 })
20738
20739 (** Delete user onboarding
20740
20741 Delete the onboarding status of the current user. *)
20742 let delete_user_onboarding client () =
20743 let op_name = "delete_user_onboarding" in
20744 let url_path = "/users/me/onboarding" in
20745 let query = "" in
20746 let url = client.base_url ^ url_path ^ query in
20747 let response =
20748 try Requests.delete client.session url
20749 with Eio.Io _ as ex ->
20750 let bt = Printexc.get_raw_backtrace () in
20751 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20752 in
20753 if Requests.Response.ok response then
20754 Requests.Response.json response
20755 else
20756 let body = Requests.Response.text response in
20757 let parsed_body =
20758 match Jsont_bytesrw.decode_string Jsont.json body with
20759 | Ok json -> Some (Openapi.Runtime.Json json)
20760 | Error _ -> Some (Openapi.Runtime.Raw body)
20761 in
20762 raise (Openapi.Runtime.Api_error {
20763 operation = op_name;
20764 method_ = "DELETE";
20765 url;
20766 status = Requests.Response.status_code response;
20767 body;
20768 parsed_body;
20769 })
20770
20771 (** Delete user profile image
20772
20773 Delete the profile image of the current user. *)
20774 let delete_profile_image client () =
20775 let op_name = "delete_profile_image" in
20776 let url_path = "/users/profile-image" in
20777 let query = "" in
20778 let url = client.base_url ^ url_path ^ query in
20779 let response =
20780 try Requests.delete client.session url
20781 with Eio.Io _ as ex ->
20782 let bt = Printexc.get_raw_backtrace () in
20783 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20784 in
20785 if Requests.Response.ok response then
20786 Requests.Response.json response
20787 else
20788 let body = Requests.Response.text response in
20789 let parsed_body =
20790 match Jsont_bytesrw.decode_string Jsont.json body with
20791 | Ok json -> Some (Openapi.Runtime.Json json)
20792 | Error _ -> Some (Openapi.Runtime.Raw body)
20793 in
20794 raise (Openapi.Runtime.Api_error {
20795 operation = op_name;
20796 method_ = "DELETE";
20797 url;
20798 status = Requests.Response.status_code response;
20799 body;
20800 parsed_body;
20801 })
20802
20803 (** Retrieve user profile image
20804
20805 Retrieve the profile image file for a user. *)
20806 let get_profile_image ~id client () =
20807 let op_name = "get_profile_image" in
20808 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/users/{id}/profile-image" in
20809 let query = "" in
20810 let url = client.base_url ^ url_path ^ query in
20811 let response =
20812 try Requests.get client.session url
20813 with Eio.Io _ as ex ->
20814 let bt = Printexc.get_raw_backtrace () in
20815 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
20816 in
20817 if Requests.Response.ok response then
20818 Requests.Response.json response
20819 else
20820 let body = Requests.Response.text response in
20821 let parsed_body =
20822 match Jsont_bytesrw.decode_string Jsont.json body with
20823 | Ok json -> Some (Openapi.Runtime.Json json)
20824 | Error _ -> Some (Openapi.Runtime.Raw body)
20825 in
20826 raise (Openapi.Runtime.Api_error {
20827 operation = op_name;
20828 method_ = "GET";
20829 url;
20830 status = Requests.Response.status_code response;
20831 body;
20832 parsed_body;
20833 })
20834
20835 (** Retrieve unique paths
20836
20837 Retrieve a list of unique folder paths from asset original paths. *)
20838 let get_unique_original_paths client () =
20839 let op_name = "get_unique_original_paths" in
20840 let url_path = "/view/folder/unique-paths" in
20841 let query = "" in
20842 let url = client.base_url ^ url_path ^ query in
20843 let response =
20844 try Requests.get client.session url
20845 with Eio.Io _ as ex ->
20846 let bt = Printexc.get_raw_backtrace () in
20847 Eio.Exn.reraise_with_context ex bt "calling %s %s" "GET" url
20848 in
20849 if Requests.Response.ok response then
20850 Requests.Response.json response
20851 else
20852 let body = Requests.Response.text response in
20853 let parsed_body =
20854 match Jsont_bytesrw.decode_string Jsont.json body with
20855 | Ok json -> Some (Openapi.Runtime.Json json)
20856 | Error _ -> Some (Openapi.Runtime.Raw body)
20857 in
20858 raise (Openapi.Runtime.Api_error {
20859 operation = op_name;
20860 method_ = "GET";
20861 url;
20862 status = Requests.Response.status_code response;
20863 body;
20864 parsed_body;
20865 })
20866
20867 (** Delete a workflow
20868
20869 Delete a workflow by its ID. *)
20870 let delete_workflow ~id client () =
20871 let op_name = "delete_workflow" in
20872 let url_path = Openapi.Runtime.Path.render ~params:[("id", id)] "/workflows/{id}" in
20873 let query = "" in
20874 let url = client.base_url ^ url_path ^ query in
20875 let response =
20876 try Requests.delete client.session url
20877 with Eio.Io _ as ex ->
20878 let bt = Printexc.get_raw_backtrace () in
20879 Eio.Exn.reraise_with_context ex bt "calling %s %s" "DELETE" url
20880 in
20881 if Requests.Response.ok response then
20882 Requests.Response.json response
20883 else
20884 let body = Requests.Response.text response in
20885 let parsed_body =
20886 match Jsont_bytesrw.decode_string Jsont.json body with
20887 | Ok json -> Some (Openapi.Runtime.Json json)
20888 | Error _ -> Some (Openapi.Runtime.Raw body)
20889 in
20890 raise (Openapi.Runtime.Api_error {
20891 operation = op_name;
20892 method_ = "DELETE";
20893 url;
20894 status = Requests.Response.status_code response;
20895 body;
20896 parsed_body;
20897 })
20898end